[mysql]

#default-character-set=latin1
default-character-set=gb2312

[mysqld]
#character-set-server=latin1
character-set-server=utf8

class ThreadTest
{
public:
    ThreadTest(){}
    ~ThreadTest(){}
    void startup();
    void addreq(int);

    void _threadMain();
    void _waitForNextRequest();
    void _processNextRequest();

    struct WorkerFunc OGRE_THREAD_WORKER_INHERIT
    {
        ThreadTest* mQueue;

        WorkerFunc(ThreadTest* q) 
            : mQueue(q) {}

        void operator()();

        void run();
    };
    WorkerFunc* mWorkerFunc;

    typedef std::deque<int> RequestQueue;
    RequestQueue mRequestQueue;

    OGRE_MUTEX(mRequestMutex)
    OGRE_MUTEX(mProcessMutex)
    OGRE_MUTEX(mResponseMutex)
    OGRE_THREAD_SYNCHRONISER(mRequestCondition)

};

void ThreadTest::addreq(int i)
{
    OGRE_LOCK_MUTEX(mRequestMutex)
    mRequestQueue.push_back(i);
    OGRE_THREAD_NOTIFY_ONE(mRequestCondition)
}
void ThreadTest::startup()
{
    int i=3;
    while(i>0)
    {
        mWorkerFunc = OGRE_NEW_T(WorkerFunc(this), MEMCATEGORY_GENERAL);
        OGRE_THREAD_CREATE(t, *mWorkerFunc);
        i--;
    }

}
void ThreadTest::WorkerFunc::operator()()
{
    mQueue->_threadMain();
}

void ThreadTest::WorkerFunc::run()
{
    mQueue->_threadMain();
}
void ThreadTest::_threadMain()
{
    while (true)
    {
        _waitForNextRequest();
        _processNextRequest();
    }

}

void ThreadTest::_waitForNextRequest()
{
    OGRE_LOCK_MUTEX_NAMED(mRequestMutex, queueLock);
    if (mRequestQueue.empty())
    {
        OGRE_THREAD_WAIT(mRequestCondition, mRequestMutex, queueLock);
    }

}

void ThreadTest::_processNextRequest()
{
    OGRE_LOCK_MUTEX(mProcessMutex)
    {
        OGRE_LOCK_MUTEX(mRequestMutex);
        if (!mRequestQueue.empty())
        {
            int request = mRequestQueue.front();
            mRequestQueue.pop_front();
            cout<<request<<endl;
        }
    }

}

          if (!mRequestQueue.empty())
          {
              request = mRequestQueue.front();
              mRequestQueue.pop_front();
          }
       }

       if (request)
       {
            processRequestResponse(request, false);
       }

 1void    btDiscreteDynamicsWorld::internalSingleStepSimulation(btScalar timeStep)
 2{
 3    
 4    BT_PROFILE("internalSingleStepSimulation");
 5
 6    if(0 != m_internalPreTickCallback) {
 7        (*m_internalPreTickCallback)(this, timeStep);
 8    }    
 9
10    /**////apply gravity, predict motion
11    predictUnconstraintMotion(timeStep);
12
13    btDispatcherInfo& dispatchInfo = getDispatchInfo();
14
15    dispatchInfo.m_timeStep = timeStep;
16    dispatchInfo.m_stepCount = 0;
17    dispatchInfo.m_debugDraw = getDebugDrawer();
18
19
20    createPredictiveContacts(timeStep);
21    
22    /**////perform collision detection
23    performDiscreteCollisionDetection();
24
25    calculateSimulationIslands();
26
27    
28    getSolverInfo().m_timeStep = timeStep;
29    
30
31
32    /**////solve contact and other joint constraints
33    solveConstraints(getSolverInfo());
34    
35    /**////CallbackTriggers();
36
37    ///integrate transforms
38
39    integrateTransforms(timeStep);
40
41    /**////update vehicle simulation
42    updateActions(timeStep);
43    
44    updateActivationState( timeStep );
45
46    if(0 != m_internalTickCallback) {
47        (*m_internalTickCallback)(this, timeStep);
48    }    
49}
50

void    btCollisionWorld::performDiscreteCollisionDetection()
{
    BT_PROFILE("performDiscreteCollisionDetection");

    btDispatcherInfo& dispatchInfo = getDispatchInfo();

    updateAabbs();


    computeOverlappingPairs();
* dispatcher = getDispatcher();
    {
        BT_PROFILE("dispatchAllCollisionPairs");
        if (dispatcher)
            dispatcher->dispatchAllCollisionPairs(m_broadphasePairCache->getOverlappingPairCache(),dispatchInfo,m_dispatcher1);    
       }


}

    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;
    }

    m_overlapFilterCallback就是那个回调函数

2)    computeOverlappingPairs()：
       该函数执行broad碰撞，也就是类似于AABB的粗线条碰撞，以此过滤paircache中不用进行narrow碰撞的pair

3)    dispatcher->dispatchAllCollisionPairs(m_broadphasePairCache->getOverlappingPairCache(),dispatchInfo,m_dispatcher1):
       该函数进行narrow碰撞，也就是精确碰撞，在这里，我们也可以设置回调，以过滤掉某些物体的精确碰撞
      

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());
            btCollisionObjectWrapper obj1Wrap(0,colObj1->getCollisionShape(),colObj1,colObj1->getWorldTransform());


            //dispatcher will keep algorithms persistent in the collision pair
            if (!collisionPair.m_algorithm)
            {
                collisionPair.m_algorithm = dispatcher.findAlgorithm(&obj0Wrap,&obj1Wrap);
            }

            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;

                }
            }
        }

}

这个是默认的callback所做的活，正如bulletManual上所说，可以换成我们自己的callback
 void setNearCallback(btNearCallback nearCallback)
 {
  m_nearCallback = nearCallback;
 }
另外，还可以重载btCollisionDispatcher，重写其
 virtual bool needsCollision(const btCollisionObject* body0,const btCollisionObject* body1);
 virtual bool needsResponse(const btCollisionObject* body0,const btCollisionObject* body1);
 virtual void dispatchAllCollisionPairs(btOverlappingPairCache* pairCache,const btDispatcherInfo& dispatchInfo,btDispatcher* dispatcher) ;
从而完全定制其行为

好 暂时over

#pragma  comment(lib,"lua51.lib")

 static int l_test(lua_State* l)
 {
  double d=lua_tonumber(l,1);
  lua_pushnumber(l,d*d);
  return 1;
 }

 __declspec(dllexport) int luaopen_test(lua_State* l)
 {
  static const luaL_reg maps[]={
   {"test",l_test},
   {NULL,NULL}
  };
  luaL_register(l,"mytest",maps);
  return 1;
 }
}
参数在lua中给出，而在c函数中，通过取栈操作得到参数，c经过处理，把结果压入栈中，ok

要点有二：
1. __declspec(dllexport) 要有
2. luaopen_模块名，假设生成的dll叫test.dll，那么函数名就叫luaopen_test

好 就是这样 谢谢