Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

add improved btGeneric6DofSpring2Constraint, thanks to Puhr Gabor and Tamas Umenhoffer!

Browse Source 
improved the new demo testbed (work-in-progress)
add basic Lua demo, import URDF test, STL import, obj import
This commit is contained in:
Erwin Coumans
2014-08-20 16:28:16 -07:00
parent d2509ae7a1
commit 7b28e86c7b
38 changed files with 4530 additions and 1015 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
Demos3/AllBullet2Demos/BulletDemoEntries.h
View File

@@ -11,7 +11,7 @@
#include "../bullet2/FeatherstoneMultiBodyDemo/MultiDofDemo.h"
#include "../bullet2/RagdollDemo/RagdollDemo.h"
#include "../bullet2/LuaDemo/LuaDemo.h"
#include "../bullet2/LuaDemo/LuaPhysicsSetup.h"
#include "../bullet2/ChainDemo/ChainDemo.h"
#include "../../Demos/CcdPhysicsDemo/CcdPhysicsSetup.h"
#include "../../Demos/ConstraintDemo/ConstraintPhysicsSetup.h"
@@ -19,6 +19,11 @@
#include "../ImportObjDemo/ImportObjSetup.h"
#include "../ImportSTLDemo/ImportSTLSetup.h"
static BulletDemoInterface* LuaDemoCreateFunc(SimpleOpenGL3App* app)
{
CommonPhysicsSetup* physicsSetup = new LuaPhysicsSetup(app);
return new BasicDemo(app, physicsSetup);
}
static BulletDemoInterface* MyCcdPhysicsDemoCreateFunc(SimpleOpenGL3App* app)
{
@@ -73,6 +78,8 @@ static BulletDemoEntry allDemos[]=
{ 1, "CcdDemo", MyCcdPhysicsDemoCreateFunc },
{ 1, "Kinematic", MyKinematicObjectCreateFunc },
{ 1, "Constraints", MyConstraintCreateFunc },
{ 1, "LuaDemo",LuaDemoCreateFunc},
{0,"File Formats", 0},
//@todo(erwincoumans) { 1, "bullet", MyImportSTLCreateFunc},
{ 1, "Wavefront Obj", MyImportObjCreateFunc},
@@ -95,7 +102,6 @@ static BulletDemoEntry allDemos[]=
{1,"MultiBody1",FeatherstoneDemo1::MyCreateFunc},
// {"MultiBody2",FeatherstoneDemo2::MyCreateFunc},
{1,"MultiDofDemo",MultiDofDemo::MyCreateFunc},
// {"LuaDemo",LuaDemo::MyCreateFunc}
};

192
Demos3/AllBullet2Demos/GraphingTexture.cpp Normal file
View File

@@ -0,0 +1,192 @@
#include "GraphingTexture.h"
#include "OpenGLWindow/OpenGLInclude.h"
#include <assert.h>
GraphingTexture::GraphingTexture()
:m_textureId(0),
m_width(0),
m_height(0)
{
}
GraphingTexture::~GraphingTexture()
{
destroy();
}
bool GraphingTexture::destroy()
{
//TODO(erwincoumans) release memory etc...
m_width = 0;
m_height=0;
glDeleteTextures(1,(GLuint*)&m_textureId);
m_textureId=0;
}
bool GraphingTexture::create(int texWidth, int texHeight)
{
m_width = texWidth;
m_height = texHeight;
glActiveTexture(GL_TEXTURE0);
m_imageData.resize(texWidth*texHeight*4);
for(int y=0;y<texHeight;++y)
{
// const int t=y>>5;
GLubyte* pi=&m_imageData[y*texWidth*4];
for(int x=0;x<texWidth;++x)
{
if (x>=y)//x<2||y<2||x>253||y>253)
{
pi[0]=0;
pi[1]=0;
pi[2]=255;
pi[3]=255;
} else
{
pi[0]=255;
pi[1]=0;
pi[2]=0;
pi[3]=255;
}
pi+=4;
}
}
glGenTextures(1,(GLuint*)&m_textureId);
uploadImageData();
}
void GraphingTexture::uploadImageData()
{
glBindTexture(GL_TEXTURE_2D,m_textureId);
GLint err = glGetError();
assert(err==GL_NO_ERROR);
err = glGetError();
assert(err==GL_NO_ERROR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width,m_height,0,GL_RGBA,GL_UNSIGNED_BYTE,&m_imageData[0]);
glGenerateMipmap(GL_TEXTURE_2D);
err = glGetError();
assert(err==GL_NO_ERROR);
}
#if 0
//shift the image one pixel
for(int y=0;y<texHeight;++y)
{
// const int t=y>>5;
for(int x=1;x<texWidth;++x)
{
GLubyte* org=image+(x+y*texWidth)*4;
GLubyte* dst=image+(x-1+y*texWidth)*4;
dst[0] = org[0];
dst[1] = org[1];
dst[2] = org[2];
dst[3] = org[3];
}
}
//render a new row at the right
for(int y=0;y<texHeight;++y)
{
GLubyte* pi=image+(texWidth-1+y*texWidth)*4;
pi[0]=255;
pi[1]=255;
pi[2]=255;
pi[3]=255;
if (y==texHeight*0.5)
{
pi[0]=200;
pi[1]=200;
pi[2]=200;
pi[3]=255;
}
}
{
static float timer = 0.f;
static int prevValue=0;
timer+= 0.01;
float value = 128+100*sinf(timer);
MyClamp(value,0.f,float(texHeight-1));
GLubyte* org=image+(texWidth-1+(int)value*texWidth)*4;
org[0] = 0;
org[1] = 0;
org[2] = 0;
org[3] = 255;
if (prevValue<value)
{
} else
{
}
}
{
static float timer = 1.4f;
timer+= 0.04;
float value = 128+150*sinf(timer);
MyClamp(value,0.f,float(texHeight-1));
GLubyte* org=image+(texWidth-1+(int)value*texWidth)*4;
org[0] = 0;
org[1] = 255;
org[2] = 0;
org[3] = 255;
}
{
static float timer = 1.4f;
timer+= 0.02;
float value =256+400*sinf(timer);
MyClamp(value,0.f,float(texHeight-1));
static int prevValue = 0;
GLubyte* org=image+(texWidth-1+(int)value*texWidth)*4;
org[0] = 0;
org[1] = 0;
org[2] = 255;
org[3] = 255;
if (prevValue<value)
{
for (int i=prevValue;i<value;i++)
{
GLubyte* org=image+(texHeight-1+(int)i*texWidth)*4;
org[0] = 0;
org[1] = 0;
org[2] = 255;
org[3] = 255;
}
} else
{
for (int i=value;i<prevValue;i++)
{
GLubyte* org=image+(texHeight-1+(int)i*texWidth)*4;
org[0] = 0;
org[1] = 0;
org[2] = 255;
org[3] = 255;
}
}
prevValue = value;
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texWidth,texHeight,0,GL_RGBA,GL_UNSIGNED_BYTE,image);
glGenerateMipmap(GL_TEXTURE_2D);
#endif

36
Demos3/AllBullet2Demos/GraphingTexture.h Normal file
View File

@@ -0,0 +1,36 @@
#ifndef GRAPHING_TEXTURE_H
#define GRAPHING_TEXTURE_H
#include "LinearMath/btAlignedObjectArray.h"
struct GraphingTexture
{
int m_textureId;
//assume rgba (8 bit per component, total of 32bit per pixel, for m_width*m_height pixels)
btAlignedObjectArray<unsigned char> m_imageData;
int m_width;
int m_height;
GraphingTexture();
virtual ~GraphingTexture();
bool create(int texWidth, int texHeight);
bool destroy();
void setPixel(int x, int y, unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha)
{
m_imageData[x*4+y*4*m_width+0] = red;
m_imageData[x*4+y*4*m_width+1] = green;
m_imageData[x*4+y*4*m_width+2] = blue;
m_imageData[x*4+y*4*m_width+3] = alpha;
}
void uploadImageData();
int getTextureId()
{
return m_textureId;
}
};
#endif //GRAPHING_TEXTURE_H

21
Demos3/AllBullet2Demos/GwenParameterInterface.cpp
View File

@@ -2,6 +2,7 @@
#include "../GpuDemos/gwenInternalData.h"
template<typename T>
struct MySliderEventHandler : public Gwen::Event::Handler
{
@@ -76,6 +77,24 @@ GwenParameterInterface::~GwenParameterInterface()
}
void GwenParameterInterface::setSliderValue(int sliderIndex, double sliderValue)
{
int sliderCapped = sliderValue+4;
sliderCapped /= 8;
sliderCapped *= 8;
if (sliderIndex>=0 && sliderIndex<m_paramInternalData->m_sliders.size())
{
m_paramInternalData->m_sliders[sliderIndex]->GetRangeMin();
m_paramInternalData->m_sliders[sliderIndex]->GetRangeMax();
float mappedValue =m_paramInternalData->m_sliders[sliderIndex]->GetRangeMin()+
(m_paramInternalData->m_sliders[sliderIndex]->GetRangeMax()-
m_paramInternalData->m_sliders[sliderIndex]->GetRangeMin())*sliderCapped/128.f;
printf("mappedValue = %f\n",mappedValue);
m_paramInternalData->m_sliders[sliderIndex]->SetValue(mappedValue);
}
}
#include <stdio.h>
void GwenParameterInterface::registerSliderFloatParameter(SliderParams& params)
@@ -95,7 +114,7 @@ void GwenParameterInterface::registerSliderFloatParameter(SliderParams& params)
pSlider->SetPos( 10, m_gwenInternalData->m_curYposition );
pSlider->SetSize( 100, 20 );
pSlider->SetRange( params.m_minVal, params.m_maxVal);
pSlider->SetNotchCount(20);//float(params.m_maxVal-params.m_minVal)/100.f);
pSlider->SetNotchCount(128);//float(params.m_maxVal-params.m_minVal)/100.f);
pSlider->SetClampToNotches( params.m_clampToNotches );
pSlider->SetValue( *params.m_paramValuePointer);//dimensions[i] );
char labelName[1024];

1
Demos3/AllBullet2Demos/GwenParameterInterface.h
View File

@@ -12,6 +12,7 @@ struct GwenParameterInterface : public CommonParameterInterface
GwenParameterInterface(struct GwenInternalData* gwenInternalData);
virtual ~GwenParameterInterface();
virtual void registerSliderFloatParameter(SliderParams& params);
virtual void setSliderValue(int sliderIndex, double sliderValue);
virtual void syncParameters();
virtual void removeAllParameters();

291
Demos3/AllBullet2Demos/GwenProfileWindow.cpp Normal file
View File

@@ -0,0 +1,291 @@
#include "../GpuDemos/gwenUserInterface.h"
#include "../GpuDemos/gwenInternalData.h"
#include "LinearMath/btQuickprof.h"
class MyProfileWindow : public Gwen::Controls::WindowControl
{
// Gwen::Controls::TabControl* m_TabControl;
//Gwen::Controls::ListBox* m_TextOutput;
unsigned int m_iFrames;
float m_fLastSecond;
Gwen::Controls::TreeNode* m_node;
Gwen::Controls::TreeControl* m_ctrl;
protected:
void onButtonA( Gwen::Controls::Base* pControl )
{
// OpenTissue::glut::toggleIdle();
}
void SliderMoved(Gwen::Controls::Base* pControl )
{
Gwen::Controls::Slider* pSlider = (Gwen::Controls::Slider*)pControl;
//this->m_app->scaleYoungModulus(pSlider->GetValue());
// printf("Slider Value: %.2f", pSlider->GetValue() );
}
void OnCheckChangedStiffnessWarping (Gwen::Controls::Base* pControl)
{
Gwen::Controls::CheckBox* labeled = (Gwen::Controls::CheckBox* )pControl;
bool checked = labeled->IsChecked();
//m_app->m_stiffness_warp_on = checked;
}
public:
CProfileIterator* profIter;
MyProfileWindow ( Gwen::Controls::Base* pParent)
: Gwen::Controls::WindowControl( pParent ),
profIter(0)
{
SetTitle( L"Time Profiler" );
SetSize( 450, 450 );
this->SetPos(10,400);
// this->Dock( Gwen::Pos::Bottom);
{
m_ctrl = new Gwen::Controls::TreeControl( this );
m_node = m_ctrl->AddNode( L"Total Parent Time" );
//Gwen::Controls::TreeNode* pNode = ctrl->AddNode( L"Node Two" );
//pNode->AddNode( L"Node Two Inside" );
//pNode->AddNode( L"Eyes" );
//pNode->AddNode( L"Brown" )->AddNode( L"Node Two Inside" )->AddNode( L"Eyes" )->AddNode( L"Brown" );
//Gwen::Controls::TreeNode* node = ctrl->AddNode( L"Node Three" );
//m_ctrl->Dock(Gwen::Pos::Bottom);
m_ctrl->ExpandAll();
m_ctrl->SetKeyboardInputEnabled(true);
m_ctrl->SetBounds( this->GetInnerBounds().x,this->GetInnerBounds().y,this->GetInnerBounds().w,this->GetInnerBounds().h);
}
}
float dumpRecursive(CProfileIterator* profileIterator, Gwen::Controls::TreeNode* parentNode)
{
profileIterator->First();
if (profileIterator->Is_Done())
return 0.f;
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();
//printf("Profiling: %s (total running time: %.3f ms) ---\n", profileIterator->Get_Current_Parent_Name(), parent_time );
float totalTime = 0.f;
int numChildren = 0;
Gwen::UnicodeString txt;
std::vector<Gwen::Controls::TreeNode*> nodes;
for (i = 0; !profileIterator->Is_Done(); i++,profileIterator->Next())
{
numChildren++;
float current_total_time = profileIterator->Get_Current_Total_Time();
accumulated_time += current_total_time;
double fraction = parent_time > SIMD_EPSILON ? (current_total_time / parent_time) * 100 : 0.f;
Gwen::String name(profileIterator->Get_Current_Name());
#ifdef _WIN32
Gwen::UnicodeString uname = Gwen::Utility::StringToUnicode(name);
txt = Gwen::Utility::Format(L"%s (%.2f %%) :: %.3f ms / frame (%d calls)",uname.c_str(), fraction,(current_total_time / (double)frames_since_reset),profileIterator->Get_Current_Total_Calls());
#else
txt = Gwen::Utility::Format(L"%s (%.2f %%) :: %.3f ms / frame (%d calls)",name.c_str(), fraction,(current_total_time / (double)frames_since_reset),profileIterator->Get_Current_Total_Calls());
#endif
Gwen::Controls::TreeNode* childNode = (Gwen::Controls::TreeNode*)profileIterator->Get_Current_UserPointer();
if (!childNode)
{
childNode = parentNode->AddNode(L"");
profileIterator->Set_Current_UserPointer(childNode);
}
childNode->SetText(txt);
nodes.push_back(childNode);
totalTime += current_total_time;
//recurse into children
}
for (i=0;i<numChildren;i++)
{
profileIterator->Enter_Child(i);
Gwen::Controls::TreeNode* curNode = nodes[i];
dumpRecursive(profileIterator, curNode);
profileIterator->Enter_Parent();
}
return accumulated_time;
}
void UpdateText(CProfileIterator* profileIterator, bool idle)
{
static bool update=true;
m_ctrl->SetBounds(0,0,this->GetInnerBounds().w,this->GetInnerBounds().h);
// if (!update)
// return;
update=false;
static int test = 1;
test++;
static double time_since_reset = 0.f;
if (!idle)
{
time_since_reset = CProfileManager::Get_Time_Since_Reset();
}
//Gwen::UnicodeString txt = Gwen::Utility::Format( L"FEM Settings %i fps", test );
{
//recompute profiling data, and store profile strings
char blockTime[128];
double totalTime = 0;
int frames_since_reset = CProfileManager::Get_Frame_Count_Since_Reset();
profileIterator->First();
double parent_time = profileIterator->Is_Root() ? time_since_reset : profileIterator->Get_Current_Parent_Total_Time();
Gwen::Controls::TreeNode* curParent = m_node;
double accumulated_time = dumpRecursive(profileIterator,m_node);
const char* name = profileIterator->Get_Current_Parent_Name();
#ifdef _WIN32
Gwen::UnicodeString uname = Gwen::Utility::StringToUnicode(name);
Gwen::UnicodeString txt = Gwen::Utility::Format( L"Profiling: %s total time: %.3f ms, unaccounted %.3f %% :: %.3f ms", uname.c_str(), parent_time ,
parent_time > SIMD_EPSILON ? ((parent_time - accumulated_time) / parent_time) * 100 : 0.f, parent_time - accumulated_time);
#else
Gwen::UnicodeString txt = Gwen::Utility::Format( L"Profiling: %s total time: %.3f ms, unaccounted %.3f %% :: %.3f ms", name, parent_time ,
parent_time > SIMD_EPSILON ? ((parent_time - accumulated_time) / parent_time) * 100 : 0.f, parent_time - accumulated_time);
#endif
//sprintf(blockTime,"--- Profiling: %s (total running time: %.3f ms) ---", profileIterator->Get_Current_Parent_Name(), parent_time );
//displayProfileString(xOffset,yStart,blockTime);
m_node->SetText(txt);
//printf("%s (%.3f %%) :: %.3f ms\n", "Unaccounted:",);
}
static int counter=10;
if (counter)
{
counter--;
m_ctrl->ExpandAll();
}
}
void PrintText( const Gwen::UnicodeString& str )
{
}
void Render( Gwen::Skin::Base* skin )
{
m_iFrames++;
if ( m_fLastSecond < Gwen::Platform::GetTimeInSeconds() )
{
SetTitle( Gwen::Utility::Format( L"Profiler %i fps", m_iFrames ) );
m_fLastSecond = Gwen::Platform::GetTimeInSeconds() + 1.0f;
m_iFrames = 0;
}
Gwen::Controls::WindowControl::Render( skin );
}
};
class MyMenuItems : public Gwen::Controls::Base
{
public:
class MyProfileWindow* m_profWindow;
MyMenuItems() :Gwen::Controls::Base(0)
{
}
void MenuItemSelect(Gwen::Controls::Base* pControl)
{
if (m_profWindow->Hidden())
{
m_profWindow->SetHidden(false);
} else
{
m_profWindow->SetHidden(true);
}
}
};
MyProfileWindow* setupProfileWindow(GwenInternalData* data)
{
MyMenuItems* menuItems = new MyMenuItems;
MyProfileWindow* profWindow = new MyProfileWindow(data->pCanvas);
//profWindow->SetHidden(true);
profWindow->profIter = CProfileManager::Get_Iterator();
data->m_viewMenu->GetMenu()->AddItem( L"Profiler", menuItems,(Gwen::Event::Handler::Function)&MyMenuItems::MenuItemSelect);
menuItems->m_profWindow = profWindow;
return profWindow;
}
void processProfileData( MyProfileWindow* profWindow, bool idle)
{
if (profWindow)
{
profWindow->UpdateText(profWindow->profIter, idle);
}
}
void profileWindowSetVisible(MyProfileWindow* window, bool visible)
{
window->SetHidden(!visible);
}
void destroyProfileWindow(MyProfileWindow* window)
{
delete window;
}

12
Demos3/AllBullet2Demos/GwenProfileWindow.h Normal file
View File

@@ -0,0 +1,12 @@
#ifndef GWEN_PROFILE_WINDOW_H
#define GWEN_PROFILE_WINDOW_H
struct MyProfileWindow* setupProfileWindow(struct GwenInternalData* data);
void processProfileData(MyProfileWindow* window, bool idle);
void profileWindowSetVisible(MyProfileWindow* window, bool visible);
void destroyProfileWindow(MyProfileWindow* window);
#endif//GWEN_PROFILE_WINDOW_H

100
Demos3/AllBullet2Demos/GwenTextureWindow.cpp Normal file
View File

@@ -0,0 +1,100 @@
#include "GwenTextureWindow.h"
#include "../GpuDemos/gwenUserInterface.h"
#include "../GpuDemos/gwenInternalData.h"
#include "Gwen/Controls/ImagePanel.h"
class MyGraphWindow : public Gwen::Controls::WindowControl
{
Gwen::Controls::ImagePanel* m_imgPanel;
public:
class MyMenuItems2* m_menuItems;
MyGraphWindow ( const MyGraphInput& input)
: Gwen::Controls::WindowControl( input.m_data->pCanvas ),
m_menuItems(0)
{
Gwen::UnicodeString str = Gwen::Utility::StringToUnicode(input.m_name);
SetTitle( str );
SetPos(input.m_xPos,input.m_yPos);
SetSize( 12+input.m_width+2*input.m_borderWidth, 30+input.m_height+2*input.m_borderWidth );
m_imgPanel = new Gwen::Controls::ImagePanel( this );
if (input.m_texName)
{
Gwen::UnicodeString texName = Gwen::Utility::StringToUnicode(input.m_texName);
m_imgPanel->SetImage( texName );
}
m_imgPanel->SetBounds( input.m_borderWidth, input.m_borderWidth,
input.m_width,
input.m_height );
// this->Dock( Gwen::Pos::Bottom);
}
virtual ~MyGraphWindow()
{
delete m_imgPanel;
}
};
class MyMenuItems2 : public Gwen::Controls::Base
{
MyGraphWindow* m_graphWindow;
public:
Gwen::Controls::MenuItem* m_item;
MyMenuItems2(MyGraphWindow* graphWindow)
:Gwen::Controls::Base(0),
m_graphWindow(graphWindow),
m_item(0)
{
}
void MenuItemSelect(Gwen::Controls::Base* pControl)
{
if (m_graphWindow->Hidden())
{
m_graphWindow->SetHidden(false);
//@TODO(erwincoumans) setCheck/SetCheckable drawing is broken, need to see what's wrong
// if (m_item)
// m_item->SetCheck(false);
} else
{
m_graphWindow->SetHidden(true);
// if (m_item)
// m_item->SetCheck(true);
}
}
};
struct MyGraphWindow* setupTextureWindow(const MyGraphInput& input)
{
MyGraphWindow* graphWindow = new MyGraphWindow(input);
MyMenuItems2* menuItems = new MyMenuItems2(graphWindow);
graphWindow->m_menuItems = menuItems;
Gwen::UnicodeString str = Gwen::Utility::StringToUnicode(input.m_name);
menuItems->m_item = input.m_data->m_viewMenu->GetMenu()->AddItem( str, menuItems,(Gwen::Event::Handler::Function)&MyMenuItems2::MenuItemSelect);
// menuItems->m_item->SetCheckable(true);
return graphWindow;
}
void destroyTextureWindow(MyGraphWindow* window)
{
delete window->m_menuItems->m_item;
delete window->m_menuItems;
delete window;
}

32
Demos3/AllBullet2Demos/GwenTextureWindow.h Normal file
View File

@@ -0,0 +1,32 @@
#ifndef GWEN_TEXTURE_WINDOW_H
#define GWEN_TEXTURE_WINDOW_H
struct MyGraphInput
{
struct GwenInternalData* m_data;
int m_xPos;
int m_yPos;
int m_width;
int m_height;
int m_borderWidth;
const char* m_name;
const char* m_texName;
MyGraphInput(struct GwenInternalData* data)
:m_data(data),
m_xPos(0),
m_yPos(0),
m_width(400),
m_height(400),
m_borderWidth(0),
m_name("GraphWindow"),
m_texName(0)
{
}
};
struct MyGraphWindow* setupTextureWindow(const MyGraphInput& input);
void destroyTextureWindow(MyGraphWindow* window);
#endif //GWEN_TEXTURE_WINDOW_H

207
Demos3/AllBullet2Demos/main.cpp
View File

@@ -1,3 +1,4 @@
#include "../../btgui/OpenGLWindow/SimpleOpenGL3App.h"
#include "Bullet3Common/b3Vector3.h"
#include "assert.h"
@@ -7,6 +8,10 @@
#include "BulletDemoEntries.h"
#include "../../btgui/Timing/b3Clock.h"
#include "GwenParameterInterface.h"
#include "GwenProfileWindow.h"
#include "GwenTextureWindow.h"
#include "GraphingTexture.h"
#define DEMO_SELECTION_COMBOBOX 13
const char* startFileName = "bulletDemo.txt";
@@ -16,13 +21,89 @@ static int sCurrentDemoIndex = 0;
static int sCurrentHightlighted = 0;
static BulletDemoInterface* sCurrentDemo = 0;
static b3AlignedObjectArray<const char*> allNames;
double motorA=0,motorB=0;
bool drawGUI=true;
extern bool useShadowMap;
static bool wireframe=false;
static bool pauseSimulation=false;
int midiBaseIndex = 176;
#ifdef B3_USE_MIDI
#include "../../btgui/MidiTest/RtMidi.h"
bool chooseMidiPort( RtMidiIn *rtmidi )
{
if (!rtmidi)
return false;
std::string portName;
unsigned int i = 0, nPorts = rtmidi->getPortCount();
if ( nPorts == 0 ) {
std::cout << "No input ports available!" << std::endl;
return false;
}
if ( nPorts == 1 ) {
std::cout << "\nOpening " << rtmidi->getPortName() << std::endl;
}
else {
for ( i=0; i<nPorts; i++ ) {
portName = rtmidi->getPortName(i);
std::cout << " Input port #" << i << ": " << portName << '\n';
}
do {
std::cout << "\nChoose a port number: ";
std::cin >> i;
} while ( i >= nPorts );
}
// std::getline( std::cin, keyHit ); // used to clear out stdin
rtmidi->openPort( i );
return true;
}
void PairMidiCallback( double deltatime, std::vector< unsigned char > *message, void *userData )
{
unsigned int nBytes = message->size();
if (nBytes==3)
{
//if ( message->at(1)==16)
{
printf("midi %d at %f = %d\n", message->at(1), deltatime, message->at(2));
//test->SetValue(message->at(2));
#if KORG_MIDI
if (message->at(0)>=midiBaseIndex && message->at(0)<(midiBaseIndex+8))
{
int sliderIndex = message->at(0)-midiBaseIndex;//-16;
printf("sliderIndex = %d\n", sliderIndex);
float sliderValue = message->at(2);
printf("sliderValue = %f\n", sliderValue);
app->m_parameterInterface->setSliderValue(sliderIndex,sliderValue);
}
#else
//ICONTROLS
if (message->at(0)==176)
{
int sliderIndex = message->at(1)-32;//-16;
printf("sliderIndex = %d\n", sliderIndex);
float sliderValue = message->at(2);
printf("sliderValue = %f\n", sliderValue);
app->m_parameterInterface->setSliderValue(sliderIndex,sliderValue);
}
#endif
}
}
}
#endif //B3_USE_MIDI
void MyKeyboardCallback(int key, int state)
{
@@ -121,7 +202,7 @@ void selectDemo(int demoIndex)
if (sCurrentDemo)
{
sCurrentDemo->initPhysics();
}
}
}
}
@@ -225,7 +306,25 @@ struct MyMenuItemHander :public Gwen::Event::Handler
};
#include "Bullet3Common/b3HashMap.h"
struct GL3TexLoader : public MyTextureLoader
{
b3HashMap<b3HashString,GLint> m_hashMap;
virtual void LoadTexture( Gwen::Texture* pTexture )
{
const char* n = pTexture->name.Get().c_str();
GLint* texIdPtr = m_hashMap[n];
if (texIdPtr)
{
pTexture->m_intData = *texIdPtr;
}
}
virtual void FreeTexture( Gwen::Texture* pTexture )
{
}
};
extern float shadowMapWorldSize;
@@ -239,6 +338,7 @@ int main(int argc, char* argv[])
int width = 1024;
int height=768;
app = new SimpleOpenGL3App("AllBullet2Demos",width,height);
app->m_instancingRenderer->setCameraDistance(13);
app->m_instancingRenderer->setCameraPitch(0);
@@ -246,7 +346,7 @@ int main(int argc, char* argv[])
app->m_window->setMouseMoveCallback(MyMouseMoveCallback);
app->m_window->setMouseButtonCallback(MyMouseButtonCallback);
app->m_window->setKeyboardCallback(MyKeyboardCallback);
GLint err = glGetError();
assert(err==GL_NO_ERROR);
@@ -257,6 +357,55 @@ int main(int argc, char* argv[])
// gui->getInternalData()->m_explorerPage
Gwen::Controls::TreeControl* tree = gui->getInternalData()->m_explorerTreeCtrl;
GL3TexLoader* myTexLoader = new GL3TexLoader;
gui->getInternalData()->pRenderer->setTextureLoader(myTexLoader);
MyProfileWindow* profWindow = setupProfileWindow(gui->getInternalData());
profileWindowSetVisible(profWindow,false);
{
MyGraphInput input(gui->getInternalData());
input.m_width=300;
input.m_height=300;
input.m_xPos = 0;
input.m_yPos = height-input.m_height;
input.m_name="Test Graph1";
input.m_texName = "graph1";
GraphingTexture* gt = new GraphingTexture;
gt->create(256,256);
int texId = gt->getTextureId();
myTexLoader->m_hashMap.insert("graph1", texId);
MyGraphWindow* gw = setupTextureWindow(input);
}
if (1)
{
MyGraphInput input(gui->getInternalData());
input.m_width=300;
input.m_height=300;
input.m_xPos = width-input.m_width;
input.m_yPos = height-input.m_height;
input.m_name="Test Graph2";
input.m_texName = "graph2";
GraphingTexture* gt = new GraphingTexture;
int texWidth = 512;
int texHeight = 512;
gt->create(texWidth,texHeight);
for (int i=0;i<texWidth;i++)
{
for (int j=0;j<texHeight;j++)
{
gt->setPixel(i,j,0,0,0,255);
}
}
gt->uploadImageData();
int texId = gt->getTextureId();
input.m_xPos = width-input.m_width;
myTexLoader->m_hashMap.insert("graph2", texId);
MyGraphWindow* gw = setupTextureWindow(input);
}
//destroyTextureWindow(gw);
app->m_parameterInterface = new GwenParameterInterface(gui->getInternalData());
@@ -323,7 +472,7 @@ int main(int argc, char* argv[])
*/
unsigned long int prevTimeInMicroseconds = clock.getTimeMicroseconds();
do
{
@@ -332,20 +481,24 @@ int main(int argc, char* argv[])
app->m_instancingRenderer->init();
DrawGridData dg;
dg.upAxis = app->getUpAxis();
app->m_instancingRenderer->updateCamera(dg.upAxis);
app->drawGrid(dg);
{
BT_PROFILE("Update Camera");
app->m_instancingRenderer->updateCamera(dg.upAxis);
}
{
BT_PROFILE("Draw Grid");
app->drawGrid(dg);
}
static int frameCount = 0;
frameCount++;
if (0)
{
char bla[1024];
sprintf(bla,"Simple test frame %d", frameCount);
app->drawText(bla,10,10);
BT_PROFILE("Draw frame counter");
char bla[1024];
sprintf(bla,"Frame %d", frameCount);
app->drawText(bla,10,10);
}
if (sCurrentDemo)
@@ -361,18 +514,34 @@ int main(int argc, char* argv[])
sCurrentDemo->stepSimulation(deltaTimeInSeconds);//1./60.f);
prevTimeInMicroseconds = curTimeInMicroseconds;
}
sCurrentDemo->renderScene();
sCurrentDemo->physicsDebugDraw();
{
BT_PROFILE("Render Scene");
sCurrentDemo->renderScene();
}
{
sCurrentDemo->physicsDebugDraw();
}
}
static int toggle = 1;
if (1)
{
gui->draw(app->m_instancingRenderer->getScreenWidth(),app->m_instancingRenderer->getScreenHeight());
if (!pauseSimulation)
processProfileData(profWindow,false);
{
BT_PROFILE("Draw Gwen GUI");
gui->draw(app->m_instancingRenderer->getScreenWidth(),app->m_instancingRenderer->getScreenHeight());
}
}
toggle=1-toggle;
app->m_parameterInterface->syncParameters();
app->swapBuffer();
{
BT_PROFILE("Sync Parameters");
app->m_parameterInterface->syncParameters();
}
{
BT_PROFILE("Swap Buffers");
app->swapBuffer();
}
} while (!app->m_window->requestedExit());
// selectDemo(0);

23
Demos3/AllBullet2Demos/premake4.lua
View File

@@ -17,12 +17,35 @@
links{"gwen", "OpenGL_Window","OpenGL_TrueTypeFont","BulletSoftBody","BulletDynamics","BulletCollision","LinearMath","lua-5.2.3"}
initOpenGL()
initGlew()
if _OPTIONS["midi"] then
if os.is("Windows") then
files {"../../btgui/MidiTest/RtMidi.cpp"}
links {"winmm"}
defines {"__WINDOWS_MM__", "WIN32","B3_USE_MIDI"}
end
if os.is("Linux") then
defines {"__LINUX_ALSA__"}
links {"asound","pthread"}
end
if os.is("MacOSX") then
files {"../../btgui/MidiTest/RtMidi.cpp"}
links{"CoreAudio.framework", "coreMIDI.framework", "Cocoa.framework"}
defines {"__MACOSX_CORE__","B3_USE_MIDI"}
end
end
files {
"**.cpp",
"**.h",
"../bullet2/BasicDemo/Bullet2RigidBodyDemo.cpp",
"../bullet2/BasicDemo/Bullet2RigidBodyDemo.h",
"../bullet2/LuaDemo/LuaPhysicsSetup.cpp",
"../bullet2/LuaDemo/LuaPhysicsSetup.h",
"../DifferentialGearDemo/DifferentialGearSetup.cpp",
"../DifferentialGearDemo/DifferentialGearSetup.h",
"../../Demos/BasicDemo/BasicDemoPhysicsSetup.cpp",
"../../Demos/BasicDemo/BasicDemoPhysicsSetup.h",
"../../Demos/CcdPhysicsDemo/CcdPhysicsSetup.cpp",