Beispiel #1
0
void SE_BipedController::finalTransformMatrix(int frameindex)
{
    for(int i = 0; i < oneBipAnimation.size(); ++i)
    {
        //use local coordinate.
        SE_Matrix4f worldToModel = mOriginalModelToWorld.inverse();

        SE_Matrix4f finalMatrix = worldToModel.mul(mAfterTransformMatrixToWorld[i]).mul(mBindposeMatrixInverse[i]).mul(mOriginalModelToWorld);

        AllFrameFinalTransformMatrix[frameindex].push_back(finalMatrix);
    }


    for(int i = 0; i < AllFrameFinalTransformMatrix[frameindex].size(); ++i)
    {
        float f[16];
        
        SE_Matrix4f m = AllFrameFinalTransformMatrix[frameindex][i];        

        m.getColumnSequence(f);

        for(int j = 0; j < 16; ++j)
        {
            AllFrameFinalTransformToShader[frameindex].push_back(f[j]);
        }
    }        

}
SE_Vector3f SE_SimObject::localToWorld(const SE_Vector3f& v)
{
    SE_Spatial* spatial = getSpatial();
    SE_Matrix4f worldTransform = spatial->getWorldTransform();
    SE_Vector4f v4(v, 1);
    v4 = worldTransform.mul(getLocalMatrix()).map(v4);
    return v4.xyz();
}
Beispiel #3
0
void SE_BipedController::createBoneBaseMatrixInverse()
{
    mBindposeMatrixInverse.clear();
    for(int i = 0; i < oneBipAnimation.size(); ++i)
    {
        SE_Matrix4f bp = oneBipAnimation[i]->bind_pose;

        mBindposeMatrixInverse.push_back(bp.inverse());
    }    
}
void SE_BoneAnimation::onEnd()
{
	if(!mSimObject)
		return;
	if(!mMesh)
		return;
	SE_Matrix4f m;
	m.identity();
	mSimObject->setWorldMatrix(m);
	mSimObject->setUseWorldMatrix(false);
	mSimObject->setPrimitiveType(TRIANGLES);
	mMesh->clearVertexInfo();
}
Beispiel #5
0
SE_Matrix4f SE_BufferInput::readMatrix4f()
{
    SE_Matrix4f m;
    for(int i = 0 ; i < 4 ; i++)
    {
        for(int j = 0 ; j < 4 ; j++)
        {
            m.set(i, j, readFloat());
        }

    }
    return m;
}
SE_Vector3f SE_SkinJointController::convert(int vertexIndex, int boneMatrixIndex, const SE_Vector3f& v)
{
    BoneWeightVector bwv = mVertexBoneWeightInfo[vertexIndex];
    BoneWeightVector::iterator it;
    SE_Vector4f result(0, 0, 0, 0);
    SE_Vector4f inputV(v.x, v.y, v.z, 1.0);
    for(it = bwv.begin() ; it != bwv.end() ; it++)
    {
        int boneIndex = it->boneIndex;
        float weight = it->weight;
        SE_Bone* bone = mBoneVector[boneIndex - 1];
		/*
        SE_Matrix4f boneBaseMatrix = bone->getBaseMatrix();
        SE_Matrix4f worldToBone;
        SE_Matrix4f boneToWorld;
        if(boneMatrixIndex == -1)
        {
            boneToWorld = bone->getBaseMatrix();
        }
        else
        {
            boneToWorld = bone->getMatrix(boneMatrixIndex);
        }
        SE_Bone* parent = bone->getParent();
        while(parent != NULL)
        {
            SE_Matrix4f parentBoneMatrix;
            if(boneMatrixIndex == -1)
                parentBoneMatrix = parent->getBaseMatrix();
            else
                parentBoneMatrix = parent->getMatrix(boneMatrixIndex);
            boneToWorld = parentBoneMatrix.mul(boneToWorld);
			SE_Matrix4f parentBaseBoneMatrix = parent->getBaseMatrix();
			boneBaseMatrix = parentBaseBoneMatrix.mul(boneBaseMatrix);
			parent = parent->getParent();
        }
        SE_Matrix4f boneBaseMatrixInverse = boneBaseMatrix.inverse();
        SE_Matrix4f m = boneToWorld.mul(boneBaseMatrixInverse);
		*/
		SE_Matrix4f boneBaseMatrixInverse = mBoneBaseMatrixInverse[boneIndex - 1];
		SE_Matrix4f boneToWorld = mBoneToWorldMatrix[boneIndex - 1];
		SE_Matrix4f m = boneToWorld.mul(boneBaseMatrixInverse);
        result = result + m.map(inputV) * weight;
    }
    return result.xyz();
}
void SE_SkinJointController::createBoneBaseMatrixInverse()
{
	mBoneBaseMatrixInverse.resize(mBoneVector.size());
	for(int i = 0 ; i < mBoneVector.size() ; i++)
	{
		SE_Bone* bone = mBoneVector[i];
		SE_Matrix4f boneBaseMatrix = bone->getBaseMatrix();
		SE_Bone* parent = bone->getParent();
		while(parent)
		{
			SE_Matrix4f parentBaseMatrix = parent->getBaseMatrix();
			boneBaseMatrix = parentBaseMatrix.mul(boneBaseMatrix);
			parent = parent->getParent();
		}
		mBoneBaseMatrixInverse[i] = boneBaseMatrix.inverse();
	}
}
void SE_BoneAnimation::onRun()
{
    if(!mSkinJointController)
        return;
    SE_Bone* bone = mSkinJointController->mBoneVector[0];
    int num = bone->getMatrixNum();
    setFrameNum(num);
    setTimePerFrame(getDuration() / num);
    mMesh = mSimObject->getMesh();
    SE_Matrix4f m;
    m.identity();
    mSimObject->setWorldMatrix(m);
    mSimObject->setUseWorldMatrix(true);
	mSimObject->setPrimitiveType(TRIANGLES_INDEX);
	mMesh->clearVertexInfo();
	mSkinJointController->createBoneBaseMatrixInverse();
}
Beispiel #9
0
void SE_BufferOutput::writeMatrix4f(const SE_Matrix4f& m)
{
    for(int i = 0 ; i < 4 ; i++)
    {
        for(int j = 0 ; j < 4 ; j++)
            writeFloat(m.get(i, j));
    }
}
Beispiel #10
0
void View::setPosition(float x, float y) {
	mX = x;
	mY = y;
	SE_Matrix3f identity3;
	identity3.identity();

	SE_Matrix4f transform;
	transform.identity();

	transform.set(identity3,SE_Vector3f(mX,mY,0));

	setPrevMatrix(transform);

	//update
	updateWorldTransform();
	updateBoundingVolume();
}
void SE_SkinJointController::createBoneToWorldMatrix(int boneMatrixIndex)
{
	if(mBoneToWorldMatrix.size() == 0)
		mBoneToWorldMatrix.resize(mBoneVector.size());
	for(int i = 0 ; i < mBoneVector.size() ; i++)
	{
		SE_Bone* bone = mBoneVector[i];
		SE_Bone* parent = bone->getParent();
		SE_Matrix4f boneToWorld = bone->getMatrix(boneMatrixIndex);
        while(parent)
		{
			SE_Matrix4f parentBoneToWorld = parent->getMatrix(boneMatrixIndex);
			boneToWorld = parentBoneToWorld.mul(boneToWorld);
			parent = parent->getParent();
		}
		mBoneToWorldMatrix[i] = boneToWorld;
	}
}
Beispiel #12
0
void SE_NewGeometry::updateWorldTransform()
{
    SE_Spatial::updateWorldTransform();
    SE_Matrix4f localM;
    localM.set(getLocalRotate().toMatrix3f(), getLocalScale(), getLocalTranslate());
    mWorldTransform = getPrevMatrix().mul(localM).mul(getPostMatrix());
    SE_NewGeometry::_Impl::SimObjectList::iterator it;
    for(it = mImpl->attachObject.begin() ; it != mImpl->attachObject.end() ; it++)
    {
        (*it)->doTransform(getWorldTransform());
    }
    std::list<SE_Spatial*>::iterator itchild = mImplchild->children.begin();
    for(; itchild != mImplchild->children.end() ; itchild++)
    {
        SE_Spatial* s = *itchild;
        s->updateWorldTransform();
    }
}
Beispiel #13
0
void SE_Camera::rotateLocal(const SE_Quat& rotate)
{
    SE_Vector3f localxAxis(1, 0, 0);
    SE_Vector3f localyAxis(0, 1, 0);
    SE_Vector3f localzAxis(0, 0, 1);
    localxAxis = rotate.map(localxAxis);
    localyAxis = rotate.map(localyAxis);
    //localzAxis = rotate.map(zAxis);
    SE_Matrix4f vtom = getViewToWorldMatrix();
    SE_Vector4f worldxAxis = vtom.map(SE_Vector4f(localxAxis, 0));
    SE_Vector4f worldyAxis = vtom.map(SE_Vector4f(localyAxis, 0));
    //SE_Vector4f worldzAxis = vtom.map(SE_Vector4f(localzAxis, 0));
	SE_Vector4f worldzAxis(worldxAxis.xyz().cross(worldyAxis.xyz()), 0);
    mAxisX = worldxAxis.normalize().xyz();
    mAxisY = worldyAxis.normalize().xyz();
    mAxisZ = worldzAxis.normalize().xyz();
    mChanged = true;
}
Beispiel #14
0
void SE_BipedController::fillBoneToWorldPerFrame()
{

    int maxFrameIndex = findMaxFrameIndex();

    for(int i = 0; i < oneBipAnimation.size(); ++i)
    {
        //get bip one by one
        SE_Biped *bip = oneBipAnimation[i];
        
        //fill bonetoworld for every frame
        for(int j = 0; j < maxFrameIndex + 1; ++j)
        {
            if(bip->parent)
            {
                SE_Matrix4f * m = new SE_Matrix4f();
                SE_Matrix4f myTrans;
                if(bip->animationInfo.size() > 0)
                {
                    //FIXME: the parent Allways has keyframe when child has keyframe
                    myTrans.set(bip->animationInfo[j]->rotateQ.toMatrix3f(),SE_Vector3f(1,1,1),bip->animationInfo[j]->translate);
                    *m = bip->parent->boneToWorldPerFrame[j]->mul(myTrans);
                }
                else
                {
                    //this bip on this frame has no key.
                    *m = bip->bind_pose;
                }
                bip->boneToWorldPerFrame.push_back(m);
            }
            else
            {
                //this bip is ROOT
                SE_Matrix4f * m = new SE_Matrix4f();
                *m = bip->bind_pose;
                bip->boneToWorldPerFrame.push_back(m);
            }

        }
       
    }

}
Beispiel #15
0
SE_Spatial* SE_ElementManager::createSpatial()
{
    if(!mRoot)
        return NULL;
    SE_Spatial* spatial = mRoot->createSpatial(NULL);
    spatial->setLocalTranslate(SE_Vector3f(0, 0, 0));
    spatial->setLocalScale(SE_Vector3f(1, 1, 1));
    SE_Vector4f c1(1, 0, 0, 0);
    SE_Vector4f c2(0, -1, 0, 0);
    SE_Vector4f c3(0, 0, 1, 0);
    SE_Vector4f c4(-mRoot->getWidth() / 2, mRoot->getHeight() / 2, 0, 1);
    SE_Matrix4f localM;
    localM.setColumn(0, c1);
    localM.setColumn(1, c2);
    localM.setColumn(2, c3);
    localM.setColumn(3, c4);
    spatial->setPostMatrix(localM);
    return spatial;
}
void SE_BoneAnimation::onUpdate(SE_TimeMS realDelta, SE_TimeMS simulateDelta, float percent, int frameIndex)
{
	if(getCurrentFrame() == frameIndex)
		return;
    if(!mSkinJointController)
        return;
    if(!mMesh)
        return;
    int surfaceNum = mMesh->getSurfaceNum();
    for(int i = 0 ; i < surfaceNum ; i++)
    {
        SE_Surface* surface = mMesh->getSurface(i);
        _Vector3f* vertex = NULL;
        int vertexNum = 0;
        int* vertexIndex = NULL;
        int vertexIndexNum = 0;
        surface->getVertex(vertex, vertexNum);
		if(!mVertex)
		{
			mVertexNum = vertexNum;
			mVertex = new _Vector3f[vertexNum];
			memcpy(mVertex, vertex, sizeof(_Vector3f) * vertexNum);
		}
        surface->getVertexIndexInGeometryData(vertexIndex, vertexIndexNum);
        if(vertex)
        {
			mSkinJointController->createBoneToWorldMatrix(frameIndex);
            for(int j = 0 ; j < vertexNum ; j++)
            {
                SE_Vector3f v(mVertex[j].d[0], mVertex[j].d[1], mVertex[j].d[2]);
				SE_Spatial* spatial = mSimObject->getSpatial();
				SE_Matrix4f worldTM = spatial->getWorldTransform();
				SE_Vector4f v4(v.x, v.y, v.z, 1.0);
				v4 = worldTM.map(v4);
				v = v4.xyz();
                v = mSkinJointController->convert(vertexIndex[j], frameIndex, v4.xyz());
                vertex[j].d[0] = v.x;
                vertex[j].d[1] = v.y;
                vertex[j].d[2] = v.z;
            }
        }
    }
}
Beispiel #17
0
void SE_BipedController::createBoneToWorldMatrix(int frameindex)
{

    //per frame refresh;
    mAfterTransformMatrixToWorld.clear();    

    for(int i = 0; i < oneBipAnimation.size(); ++i)
    {
        SE_Biped * bip = oneBipAnimation[i];

        SE_Matrix4f transform;        

        if(bip->animationInfo.size() == 0)
        {
            transform.identity();            
        }
        else
        {
            SE_Quat worldR = bip->animationInfo[frameindex]->rotateQ;
            SE_Vector3f worldT = bip->animationInfo[frameindex]->translate;
            SE_Vector3f worldS = bip->animationInfo[frameindex]->scale;
            
            //not use scale
            transform.set(worldR.toMatrix3f(),SE_Vector3f(1,1,1),worldT);//myTransform relate parent
        
        }

        SE_Matrix4f parentBoneToWorld;
        parentBoneToWorld.identity();


        if(bip->parent)
        {
            parentBoneToWorld = *(bip->parent->boneToWorldPerFrame[frameindex]);
        }
        else
        {
            //this bip is ROOT,the transform is world relative;
        }

        SE_Matrix4f tranToWorld = parentBoneToWorld.mul(transform);
        mAfterTransformMatrixToWorld.push_back(tranToWorld);
    }    
}
Beispiel #18
0
void SE_GeometryData::transform(SE_GeometryData* src, const SE_Matrix4f& m, SE_GeometryData* dst)
{
    SE_Vector3f* vertex = NULL;
    SE_Vector3i* faces = NULL;
    SE_Vector3f* facenormal = NULL;
    SE_Vector3f* facevertexnormal = NULL;

    int vertexNum = 0;
    int faceNum = 0;
    int facenormalNum = 0;
    int facevertexnormalNum = 0;

    if(src->vertexArray)
    {
        vertex = new SE_Vector3f[src->vertexNum];
        for(int i = 0 ; i < src->vertexNum ; i++)
        {
            SE_Vector4f v(src->vertexArray[i], 1.0f);
            v = m.map(v);
            vertex[i] = v.xyz();
        }
        vertexNum = src->vertexNum;
    }
    /*
    if(src->faceArray)
    {
        faces = new SE_Vector3i[src->faceNum];
        for(int i = 0 ; i < src->faceNum; i++)
        {
            faces[i] = src->faceArray[i];
        }
        faceNum = src->faceNum;
    }
    */
    if(src->faceNormalArray)
    {
        /*
        //SE_Matrix3f t = m.toMatrix3f();
        //if(t.hasInverse())
        //{
            SE_Matrix4f inverse = m.inverse();
            inverse = inverse.transpose();
            facenormal = new SE_Vector3f[src->faceNormalNum];
            for(int i = 0 ; i < src->faceNormalNum ; i++)
            {
                facenormal[i] = (inverse.map(SE_Vector4f(src->faceNormalArray[i],0))).xyz();
                LOGI("facevertexnormal[%d].x = %f\n",i,facenormal[i].x);
                LOGI("facevertexnormal[%d].y = %f\n",i,facenormal[i].y);
                LOGI("facevertexnormal[%d].z = %f\n",i,facenormal[i].z);
            }
            facenormalNum = src->faceNormalNum;
        //}
        */
    }

    if(src->faceVertexNormalArray)
    {
        /*
        SE_Matrix3f t = m.toMatrix3f();
        if(t.hasInverse())
        {
            SE_Matrix3f inverse = t.inverse();
            inverse = inverse.transpose();
            facevertexnormal = new SE_Vector3f[src->faceVertexNormalNum];
            for(int i = 0 ; i < src->faceVertexNormalNum ; i++)
            {
                facevertexnormal[i] = inverse.map(src->faceVertexNormalArray[i]);
                LOGI("facevertexnormal[%d].x = %f\n",i,facevertexnormal[i].x);
                LOGI("facevertexnormal[%d].y = %f\n",i,facevertexnormal[i].y);
                LOGI("facevertexnormal[%d].z = %f\n",i,facevertexnormal[i].z);
            }
            facevertexnormalNum = src->faceVertexNormalNum;
        }
        */
    }

    dst->setVertexArray(vertex, vertexNum);
    dst->setFaceArray(src->faceArray, src->faceNum, false);
    dst->setFaceNormalArray(facenormal, facenormalNum);
    dst->setFaceVertexNormalArray(facevertexnormal,facevertexnormalNum);
}
Beispiel #19
0
void SE_BipedController::fillFrame()
{
    int maxFrame = findMaxFrameIndex();    

    std::vector<SE_BipedKeyFrame*> fullFrame;
    //fullFrame.resize(maxFrame,NULL);

    for(int i = 0; i < oneBipAnimation.size(); ++i)
    {
        //get bip one by one
        SE_Biped *bip = oneBipAnimation[i];
         
        if(bip->animationInfo.size() == 0)
        {
            continue;//this bip has no keyframe
        }

        //generate 0 frame, bind_pos relative parent
        SE_Matrix4f bindposT;
        if(bip->parent)
        {
            bindposT = (bip->parent->bind_pose.inverse()).mul(bip->bind_pose);            
        }
        else
        {
            //this bip is ROOT
            bindposT = bip->bind_pose;
        }

        SE_Quat rotate = bindposT.toMatrix3f().toQuat();//no rotate
        rotate = rotate.inverse();
        

        SE_Vector3f translate = bindposT.getTranslate();

        SE_Vector3f scale(1,1,1); //scale no use

        SE_BipedKeyFrame *zeroFrame = new SE_BipedKeyFrame();
        zeroFrame->frameIndex = 0;            

        zeroFrame->rotateQ = rotate;
        zeroFrame->scale = scale;
        zeroFrame->translate = translate;

        //push first (0) frame to target
        fullFrame.push_back(zeroFrame);

        
     
        std::vector<SE_BipedKeyFrame*>::iterator it_s = bip->animationInfo.begin();
        std::vector<SE_BipedKeyFrame*>::iterator it_t = fullFrame.end();
        -- it_t;

        SE_BipedKeyFrame* node_s = NULL;
        SE_BipedKeyFrame* node_t = NULL;
        
        while(it_s != bip->animationInfo.end())
        {            
            node_s = *it_s;
            node_t = *it_t;
            if(needInterpolation(node_t->frameIndex,node_s->frameIndex))
            {
                //interpolation
                interpolation(it_s,it_t,fullFrame);
            
            }
            else if(node_s->frameIndex == node_t->frameIndex)//current source frame index == target frame index
            {
                //goto next frame
                ++it_s;
            }
            else //source frame index - target frame index == 1
            {
                //push source frame to target frame vector
                SE_BipedKeyFrame *nextFrame = new SE_BipedKeyFrame();

                //current source node is just next frame
                nextFrame->frameIndex = node_s->frameIndex;
                nextFrame->rotateQ = node_s->rotateQ;
                nextFrame->translate = node_s->translate;
                nextFrame->scale = node_s->scale;

                fullFrame.push_back(nextFrame);
                it_t = fullFrame.end();
                --it_t;

            }
            
        }

        //total frame little than maxFrame?
        //1.yes fill last frame to vector
        
        int lastframe = bip->animationInfo.size() - 1;
        int lastframeIndex = bip->animationInfo[lastframe]->frameIndex;
        if(lastframeIndex < maxFrame)
        {
            SE_BipedKeyFrame * lastframenode = bip->animationInfo[lastframe];

            for(int needfill = 0; needfill < maxFrame - lastframeIndex; ++needfill)
            {
                SE_BipedKeyFrame *fillFrame = new SE_BipedKeyFrame();

                //next (maxFrame - lastframeIndex) frames are same 
                fillFrame->frameIndex = lastframenode->frameIndex + needfill + 1;
                fillFrame->rotateQ = lastframenode->rotateQ;
                fillFrame->translate = lastframenode->translate;
                fillFrame->scale = lastframenode->scale;

                fullFrame.push_back(fillFrame);

            }
        }

        //2.no,finish this biped,copy target to source,clear target
        for(it_s = bip->animationInfo.begin(); it_s != bip->animationInfo.end(); ++it_s)
        {
            if(*it_s != NULL)
            {
                delete *it_s;
            }
        }
        bip->animationInfo.clear();

        bip->animationInfo.resize(fullFrame.size());
        
        //copy target to source
        std::copy(fullFrame.begin(),fullFrame.end(),bip->animationInfo.begin());

        //clear fullFrame vector
        fullFrame.clear();        

    }

}
Beispiel #20
0
SE_Vector3f SE_BipedController::convert(int vertexIndex,int frameindex,const char * objname, const SE_Vector3f& v)
{
    SE_Vector4f input;
    input.set(v,1);
    SE_Vector4f result(0,0,0,0);

    SE_SkeletonUnit *su = findSU(objname);

    //bipedIndex.size is number that how many bips effact this vertext.
    int bipNumPerVertex = su->objVertexBlendInfo[vertexIndex]->bipedIndex.size();  

    //how many bips will take effact to one vertex
    for(int i = 0; i < bipNumPerVertex; ++i)
    {
        int bipIndex = su->objVertexBlendInfo[vertexIndex]->bipedIndex[i];//bipIndex is start from 1, not 0.

        int bipindexfromcache = su->bipCache[bipIndex-1]->bipIndexOnBipAnimation;

        SE_Biped *bip = oneBipAnimation[bipindexfromcache];// find bip from all bips

        if(bip->animationInfo.size() == 0)
        {
            continue;
        }

#ifdef _FORDEBUG
        SE_Matrix4f bindpos = bip->bind_pose;
        SE_Matrix4f inversOfbp = bindpos.inverse();

        SE_Quat worldR = bip->animationInfo[frameindex]->rotateQ;
        SE_Vector3f worldT = bip->animationInfo[frameindex]->translate;
        SE_Vector3f worldS = bip->animationInfo[frameindex]->scale;

        SE_Matrix4f transform;
        transform.identity();
        //not use scale
        transform.set(worldR.toMatrix3f(),SE_Vector3f(1,1,1),worldT);//myTransform relate parent        

        SE_Matrix4f parentBoneToWorld;
        parentBoneToWorld.identity();

        if(bip->parent)
        {
            parentBoneToWorld = *(bip->parent->boneToWorldPerFrame[frameindex]);
        }
        else
        {
            //this bip is ROOT,the transform is world relative;
        }        

        SE_Matrix4f m = parentBoneToWorld.mul(transform).mul(inversOfbp);

        SE_Matrix4f m = mAfterTransformMatrixToWorld[bipindexfromcache].mul(mBindposeMatrixInverse[bipindexfromcache]);
#else
        SE_Matrix4f m = AllFrameFinalTransformMatrix[frameindex][bipindexfromcache];
#endif

        result = result + m.map(input) * su->objVertexBlendInfo[vertexIndex]->weight[i];
    }
    return result.xyz();
}
Beispiel #21
0
SE_Matrix4f SE_Camera::getWorldToViewMatrix() const
{
    SE_Matrix4f vtow = getViewToWorldMatrix();
    return vtow.inverse(); 
}
Beispiel #22
0
void SE_Camera::getFrustumPlanes(SE_Plane planes[6]) const
{
	if(!mChanged)
	{
		for(int i = 0 ; i < 6 ; i++)
		{
			planes[i] = mPlanes[i];
		}
		return;
	}
    SE_Plane lplanes[6];
    lplanes[0] = mFrustum.getLeftPlane();
    lplanes[1] = mFrustum.getRightPlane();
    lplanes[2] = mFrustum.getTopPlane();
    lplanes[3] = mFrustum.getBottomPlane();
    lplanes[4] = mFrustum.getNearPlane();
    lplanes[5] = mFrustum.getFarPlane();
    SE_Matrix4f vtom = getViewToWorldMatrix();
    vtom = vtom.inverse();
    vtom = vtom.transpose();
    for(int i = 0 ; i < 6 ; i++)
    {
        SE_Plane p = lplanes[i].transform(vtom);
		planes[i].set(p.getNormal().neg(), p.getDistance());
		mPlanes[i] = planes[i];
    }
#ifdef DEBUG
	/*
	SE_Plane nplanes[6];
	SE_Vector3f NearLeftBottom, NearLeftTop, NearRightBottom, NearRightTop,
		        FarLeftBottom, FarLeftTop, FarRightBottom, FarRightTop;
	SE_Vector3f tmp1;
	SE_Vector3f tmp[4];
	SE_Rect<float> nearplane = mFrustum.getNearPlaneRect();
	tmp[0] = mAxisZ.mul(-mFrustum.getNear());
	tmp[1] = mAxisX.mul(nearplane.left);
	tmp[2] = mAxisY.mul(nearplane.bottom);
	tmp[3] = mLocation;
	NearLeftBottom = tmp[0] + tmp[1] + tmp[2] + tmp[3];
	tmp1 = tmp[0] + tmp[1] + tmp[2];
	tmp1 = tmp1.mul(mFrustum.getFar() / mFrustum.getNear());
	FarLeftBottom = mLocation + tmp1;

	tmp[1] = mAxisX.mul(nearplane.left);
	tmp[2] = mAxisY.mul(nearplane.top);
	NearLeftTop = tmp[0] + tmp[1] + tmp[2] + tmp[3];
    tmp1 = tmp[0] + tmp[1] + tmp[2];
	tmp1 = tmp1.mul(mFrustum.getFar() / mFrustum.getNear());
	FarLeftTop = mLocation + tmp1;

	tmp[1] = mAxisX.mul(nearplane.right);
	tmp[2] = mAxisY.mul(nearplane.bottom);
	NearRightBottom = tmp[0] + tmp[1] + tmp[2] + tmp[3];
    tmp1 = tmp[0] + tmp[1] + tmp[2];
	tmp1 = tmp1.mul(mFrustum.getFar() / mFrustum.getNear());
	FarRightBottom = mLocation + tmp1;

	tmp[1] = mAxisX.mul(nearplane.right);
	tmp[2] = mAxisY.mul(nearplane.top);
	NearRightTop = tmp[0] + tmp[1] + tmp[2] + tmp[3];

	tmp1 = tmp[0] + tmp[1] + tmp[2];
	tmp1 = tmp1.mul(mFrustum.getFar() / mFrustum.getNear());
	FarRightTop = mLocation + tmp1;

	nplanes[0].set(NearLeftBottom, mLocation, NearLeftTop);
	nplanes[1].set(NearRightTop, mLocation, NearRightBottom);
	nplanes[2].set(mLocation, NearLeftBottom, NearRightBottom);
	nplanes[3].set(mLocation, NearRightTop, NearLeftTop);
	nplanes[4].set(NearLeftBottom, NearRightBottom, NearRightTop);
	nplanes[5].set(FarLeftBottom, FarLeftTop, FarRightTop);
    for(int i = 0 ; i < 6 ; i++)
    {
        planes[i] = nplanes[i];
    }
	*/
#endif
}