Cocos2d-x3.3RC0 Cpp-test分析之Camera3DDemo

概述http://www.58player.com/blog-2532-131989.html 已有 62 次阅读2014-11-19 20:30 |系统分类:Cocos2d| 手游研发         1、Camera3DDemo                    //.h         #include "cocos2d.h"         #include <string>        http://www.58player.com/blog-2532-131989.HTML

已有 62 次阅读2014-11-19 20:30|系统分类:Cocos2d|手游研发

1、Camera3DDemo

//.h
#include"cocos2d.h"
#include<string>
USING_NS_CC;

#include<string>
namespacecocos2d{
classsprite3D;
classDelay;
}
enumState
{
State_None=0,
State_IDle=0x01,
State_Move=0x02,
State_Rotate=0x04,
State_Speak=0x08,
State_MeleeAttack=0x10,
State_RemoteAttack=0x20,
State_Attack=0x40,
};
enumclassCameraType
{
FreeCamera=0,
FirstCamera=1,
ThirdCamera=2,
};
classCamera3DTestDemo:publicLayer
{
public:
CREATE_FUNC(Camera3DTestDemo);
Camera3DTestDemo(voID);
virtual~Camera3DTestDemo(voID);

virtualvoIDonEnter()overrIDe;
virtualvoIDonExit()overrIDe;

voIDaddNewSpriteWithCoords(Vec3p,std::stringfilename,boolplayAnimation=false,floatscale=1.0f,boolbindCamera=false);
voIDontouchesBegan(conststd::vector<touch*>&touches,cocos2d::Event*event);
voIDontouchesMoved(conststd::vector<touch*>&touches,cocos2d::Event*event);
voIDontouchesEnded(conststd::vector<touch*>&touches,cocos2d::Event*event);
voIDSwitchVIEwCallback(Ref*sender,CameraTypecameraType);
voIDupdateCamera(floatfDelta);
voIDmove3D(floatelapsedtime);
voIDupdateState(floatelapsedtime);
boolisstate(unsignedintstate,unsignedintbit)const;

boolontouchesZoomOut(touch*touch,Event*event);
voIDontouchesZoomOutEnd(touch*touch,Event*event);
boolontouchesZoomIn(touch*touch,Event*event);
voIDontouchesZoominend(touch*touch,Event*event);

boolontouchesRotateleft(touch*touch,Event*event);
voIDontouchesRotateleftEnd(touch*touch,Event*event);
boolontouchesRotateRight(touch*touch,Event*event);
voIDontouchesRotateRightEnd(touch*touch,Event*event);
protected:
std::string_Title;
Layer*_layer3D;
Sprite3D*_sprite3D;
Vec3_targetPos;
CameraType_cameraType;
MenuItem*_incRot;
MenuItem*_decRot;
unsignedint_curState;
Camera*_camera;
Moveto*_moveAction;
bool_bZoomOut;
bool_bZoomIn;
bool_brotateleft;
bool_brotateRight;
Label*_RotateRightlabel;
Label*_Rotateleftlabel;
Label*_ZoomInlabel;
Label*_ZoomOutlabel;
};

.cpp

#include"Camera3DDemo.h"
#include<algorithm>//包含STL库的算法
#include"VisibleRect.h"

classDrawline3D:publicNode
{
public:
//静态创建函数
staticDrawline3D*create();
//画线函数，参数1:起点；参数2:终点；参数3:线段颜色
voIDdrawline(constVec3&from,constVec3&to,constcolor4F&color);
voIDclear()
{
_buffer.clear();
}
//真正的绘图函数
voIDonDraw(constMat4&transform,uint32_tflags);
//绘制节点
virtualvoIDdraw(Renderer*renderer,constMat4&transform,uint32_tflags)overrIDe;

CC_CONSTRUCTOR_ACCESS:
Drawline3D()
{

}
virtual~Drawline3D()
{

}
virtualboolinit();

protected:
//自定义线段存放的结构体
structV3F_C4B
{
Vec3vertices;//线段端点坐标
color4Bcolors;//线段颜色
};
//存放线段数据的容器
std::vector<V3F_C4B>_buffer;
//启动自定义绘图
CustomCommand_customCommand;

private:
//CC_disALLOW_copY_AND_ASSIGN宏的作用是定义一个类，禁止拷贝和赋值(=)运算符重载功能。
CC_disALLOW_copY_AND_ASSIGN(Drawline3D);
};

Drawline3D*Drawline3D::create()
{
//nothrow创建对象失败返回0
autoret=new(std::nothrow)Drawline3D();
//对象创建成功
if(ret&&ret->init())
returnret;
//对象创建失败
CC_SAFE_DELETE(ret);
returnnullptr;
}

boolDrawline3D::init()
{
//设置节点着色程序
setGLProgramState(GLProgramState::getorCreateWithGLProgramname(GLProgram::SHADER_name_position_color));
returntrue;
}
//画线函数
voIDDrawline3D::drawline(constVec3&from,constcolor4F&color)
{
color4Bcol=color4B(color);//线段颜色
Drawline3D::V3F_C4Bvertex;
vertex.vertices=from;//起点信息
vertex.colors=col;
_buffer.push_back(vertex);
vertex.vertices=to;//终点信息
_buffer.push_back(vertex);
}
//绘制节点函数
voIDDrawline3D::draw(Renderer*renderer,uint32_tflags)
{
_customCommand.init(_globalZOrder);
////调用真正的绘图函数onDraw
_customCommand.func=CC_CALLBACK_0(Drawline3D::onDraw,this,transform,flags);
//将着色器程序加入renderer对象
renderer->addCommand(&_customCommand);
}
//真正的调用OpenGL接口绘图，涉及OpenGL知识，暂不了解
voIDDrawline3D::onDraw(constMat4&transform,uint32_tflags)
{
autoglProgram=getGLProgram();//返回当前节点的GLProgram(shader)
glProgram->use();//调用gluseProgram()函数，使用shader绘图
glProgram->setUniformsForBuiltins(transform);
glEnable(GL_DEPTH_TEST);
glBindBuffer(GL_ARRAY_BUFFER,0);
glEnabLevertexAttribarray(GLProgram::VERTEX_ATTRIB_position);
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_position,3,GL_float,GL_FALSE,sizeof(V3F_C4B),&(_buffer[0].vertices));

glEnabLevertexAttribarray(GLProgram::VERTEX_ATTRIB_color);
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_color,4,GL_UNSIGNED_BYTE,GL_TRUE,&(_buffer[0].colors));
glDrawArrays(GL_lines,static_cast<int>(_buffer.size()));
gldisable(GL_DEPTH_TEST);
}

////////////////////////////////////////////////////////////////////////////////

enum
{
IDC_NEXT=100,
IDC_BACK,
IDC_RESTART
};

Camera3DTestDemo::Camera3DTestDemo(voID)
:Layer()
,_camera(nullptr)
,_incRot(nullptr)
,_decRot(nullptr)
,_bZoomOut(false)
,_bZoomIn(false)
,_brotateleft(false)
,_brotateRight(false)
{

}
Camera3DTestDemo::~Camera3DTestDemo(voID)
{
}
//旋转视角回调函数
voIDCamera3DTestDemo::SwitchVIEwCallback(Ref*sender,CameraTypecameraType)
{
//如果当前视角等于要转换的视角，则直接返回
if(_cameraType==cameraType)
{
return;
}
_cameraType=cameraType;

//如果摄像机类型等于自由视角
if(_cameraType==CameraType::FreeCamera)
{
_camera->setposition3D(Vec3(0,130,130)+_sprite3D->getposition3D());
_camera->lookAt(_sprite3D->getposition3D(),Vec3(0,1,0));

_RotateRightlabel->setcolor(color3B::WHITE);
_Rotateleftlabel->setcolor(color3B::WHITE);
_ZoomInlabel->setcolor(color3B::WHITE);
_ZoomOutlabel->setcolor(color3B::WHITE);
}
//如果摄像机类型为第一视角
elseif(_cameraType==CameraType::FirstCamera)
{
Vec3newFaceDir;
//返回逆世界仿射变换矩阵。像素的矩阵。并获取Forward矩阵，参数为目标向量
_sprite3D->getWorldToNodetransform().getForwardVector(&newFaceDir);
//目标向量标准化，将Vec3对象的x，y，z转化为分数，且x的平方+y的平方+z的平方=1
newFaceDir.normalize();
_camera->setposition3D(Vec3(0,35,0)+_sprite3D->getposition3D());
//设置相机的视图矩阵，参数1：target位置，参数2：向上的向量
_camera->lookAt(_sprite3D->getposition3D()+newFaceDir*50,0));

_RotateRightlabel->setcolor(color3B::WHITE);
_Rotateleftlabel->setcolor(color3B::WHITE);
_ZoomInlabel->setcolor(color3B::GRAY);
_ZoomOutlabel->setcolor(color3B::GRAY);
}
//如果摄像机的类型为第三视角
elseif(_cameraType==CameraType::ThirdCamera)
{
_camera->setposition3D(Vec3(0,130)+_sprite3D->getposition3D());
//设置相机的视图矩阵。
_camera->lookAt(_sprite3D->getposition3D(),0));
_RotateRightlabel->setcolor(color3B::GRAY);
_Rotateleftlabel->setcolor(color3B::GRAY);
_ZoomInlabel->setcolor(color3B::WHITE);
_ZoomOutlabel->setcolor(color3B::WHITE);
}
}
voIDCamera3DTestDemo::onEnter()
{
Layer::onEnter();
_sprite3D=nullptr;
//注册事件
autos=Director::getInstance()->getWinSize();
autoListener=EventListenertouchAllAtOnce::create();
Listener->ontouchesBegan=CC_CALLBACK_2(Camera3DTestDemo::ontouchesBegan,this);
Listener->ontouchesMoved=CC_CALLBACK_2(Camera3DTestDemo::ontouchesMoved,this);
Listener->ontouchesEnded=CC_CALLBACK_2(Camera3DTestDemo::ontouchesEnded,this);
_eventdispatcher->addEventListenerWithSceneGraPHPriority(Listener,this);
//创建新的层，用于加载3D精灵和线段
autolayer3D=Layer::create();
addChild(layer3D,0);
_layer3D=layer3D;
_curState=State_None;
//添加精灵参数依次为：Vec3向量，精灵文件路径，是否执行动作，缩放系数，是否绑定摄像机
addNewSpriteWithCoords(Vec3(0,0),"girl.c3b",true,0.2f,true);
TTFConfigttfConfig("Fonts/arial.ttf",30);
//依次添加4个Label对象到对应的Node节点上，并对4个Label对象注册监听事件
autocontainerForLabel1=Node::create();
_ZoomOutlabel=Label::createWithTTF(ttfConfig,"zoomout");
_ZoomOutlabel->setposition(s.wIDth-150,VisibleRect::top().y-30);
containerForLabel1->addChild(_ZoomOutlabel);
addChild(containerForLabel1,10);

autoListener1=EventListenertouchOneByOne::create();
Listener1->setSwallowtouches(true);

Listener1->ontouchBegan=CC_CALLBACK_2(Camera3DTestDemo::ontouchesZoomOut,this);
Listener1->ontouchended=CC_CALLBACK_2(Camera3DTestDemo::ontouchesZoomOutEnd,this);

_eventdispatcher->addEventListenerWithSceneGraPHPriority(Listener1,_ZoomOutlabel);

autocontainerForLabel2=Node::create();
_ZoomInlabel=Label::createWithTTF(ttfConfig,"zoomin");
_ZoomInlabel->setposition(s.wIDth-150,VisibleRect::top().y-100);
containerForLabel2->addChild(_ZoomInlabel);
addChild(containerForLabel2,10);

autoListener2=EventListenertouchOneByOne::create();
Listener2->setSwallowtouches(true);

Listener2->ontouchBegan=CC_CALLBACK_2(Camera3DTestDemo::ontouchesZoomIn,this);
Listener2->ontouchended=CC_CALLBACK_2(Camera3DTestDemo::ontouchesZoominend,this);

_eventdispatcher->addEventListenerWithSceneGraPHPriority(Listener2,_ZoomInlabel);

autocontainerForLabel3=Node::create();
_Rotateleftlabel=Label::createWithTTF(ttfConfig,"rotateleft");
_Rotateleftlabel->setposition(s.wIDth-150,VisibleRect::top().y-170);
containerForLabel3->addChild(_Rotateleftlabel);
addChild(containerForLabel3,10);

autoListener3=EventListenertouchOneByOne::create();
Listener3->setSwallowtouches(true);

Listener3->ontouchBegan=CC_CALLBACK_2(Camera3DTestDemo::ontouchesRotateleft,this);
Listener3->ontouchended=CC_CALLBACK_2(Camera3DTestDemo::ontouchesRotateleftEnd,this);

_eventdispatcher->addEventListenerWithSceneGraPHPriority(Listener3,_Rotateleftlabel);

autocontainerForLabel4=Node::create();
_RotateRightlabel=Label::createWithTTF(ttfConfig,"rotateright");
_RotateRightlabel->setposition(s.wIDth-150,VisibleRect::top().y-240);
containerForLabel4->addChild(_RotateRightlabel);
addChild(containerForLabel4,10);

autoListener4=EventListenertouchOneByOne::create();
Listener4->setSwallowtouches(true);

Listener4->ontouchBegan=CC_CALLBACK_2(Camera3DTestDemo::ontouchesRotateRight,this);
Listener4->ontouchended=CC_CALLBACK_2(Camera3DTestDemo::ontouchesRotateRightEnd,this);

_eventdispatcher->addEventListenerWithSceneGraPHPriority(Listener4,_RotateRightlabel);

//设置摄像机视角菜单选项，并回调转换视角函数
autolabel1=Label::createWithTTF(ttfConfig,"free");
automenuItem1=MenuItemLabel::create(label1,CC_CALLBACK_1(Camera3DTestDemo::SwitchVIEwCallback,CameraType::FreeCamera));
autolabel2=Label::createWithTTF(ttfConfig,"thirdperson");
automenuItem2=MenuItemLabel::create(label2,CameraType::ThirdCamera));
autolabel3=Label::createWithTTF(ttfConfig,"firstperson");
automenuItem3=MenuItemLabel::create(label3,CameraType::FirstCamera));
automenu=Menu::create(menuItem1,menuItem2,menuItem3,nullptr);

menu->setposition(Vec2::ZERO);

menuItem1->setposition(VisibleRect::left().x+100,VisibleRect::top().y-50);
menuItem2->setposition(VisibleRect::left().x+100,VisibleRect::top().y-100);
menuItem3->setposition(VisibleRect::left().x+100,VisibleRect::top().y-150);
addChild(menu,0);
//设置自定义更新器，时间间隔为0.0秒
schedule(CC_SCHEDulE_SELECTOR(Camera3DTestDemo::updateCamera),0.0f);
if(_camera==nullptr)
{
//初始化相机
_camera=Camera::createPerspective(60,(GLfloat)s.wIDth/s.height,1000);
_camera->setCameraFlag(CameraFlag::USER1);
_layer3D->addChild(_camera);
}
//首先执行视角切换回调函数，先切换到第三视角
SwitchVIEwCallback(this,CameraType::ThirdCamera);

//创建3D画线类对象
Drawline3D*line=Drawline3D::create();
//drawx
for(intj=-20;j<=20;j++)
{
//将线段信息存入vector，调用draw绘图，实质是onDraw进行绘制
line->drawline(Vec3(-100,5*j),Vec3(100,color4F(1,1));
}
//drawz
for(intj=-20;j<=20;j++)
{
//将线段信息存入vector，调用draw绘图，实质是onDraw进行绘制
line->drawline(Vec3(5*j,-100),Vec3(5*j,100),color4F(0,1));
}
//drawy//绘制y轴方向的两条线段
line->drawline(Vec3(0,-50,0.5,1));
line->drawline(Vec3(0,50,1));
_layer3D->addChild(line);
//设置mask，使得其对相机可见
_layer3D->setCameraMask(2);
}
//onExit函数，退出当前层时执行
voIDCamera3DTestDemo::onExit()
{
Layer::onExit();
if(_camera)
{
_camera=nullptr;
}
}
//添加精灵，参数1:精灵坐标，参数2:精灵文件路径，参数3:是否执行动作，参数4:缩放系数，参数5:是否绑定摄像机
voIDCamera3DTestDemo::addNewSpriteWithCoords(Vec3p,boolplayAnimation,floatscale,boolbindCamera)
{
//创建3D精灵
autosprite=Sprite3D::create(filename);
_layer3D->addChild(sprite);
floatglobalZOrder=sprite->getGlobalZOrder();
//设置精灵的坐标和全局Z轴顺序
sprite->setposition3D(Vec3(p.x,p.y,p.z));
sprite->setGlobalZOrder(globalZOrder);
if(playAnimation)
{
//首先通过骨骼节点创建骨骼动画
autoanimation=Animation3D::create(filename,"Take001");
if(animation)
{
//执行3D动画
autoanimate=Animate3D::create(animation);
sprite->runAction(RepeatForever::create(animate));
}
}
//如果绑定摄像机，将sprite赋值给_sprite3D对象
if(bindCamera)
{
_sprite3D=sprite;
}
sprite->setScale(scale);

}
//多点触摸
voIDCamera3DTestDemo::ontouchesBegan(conststd::vector<touch*>&touches,cocos2d::Event*event)
{
for(auto&item:touches)
{
autotouch=item;
autolocation=touch->getLocation();
}
}
//多点触摸移动，即点击线段区域，精灵移动过去
voIDCamera3DTestDemo::ontouchesMoved(conststd::vector<touch*>&touches,cocos2d::Event*event)
{
if(touches.size()==1)
{
autotouch=touches[0];
//获取第一个触摸点的OpenGL坐标系的坐标，原点在屏幕左下角。
//补充：屏幕坐标系，原点在屏幕左上角
//世界坐标系：与OpenGL坐标系一致，位于屏幕左下角
//节点坐标系：父节点的左下角，与OpenGL一致
autolocation=touch->getLocation();
PointnewPos=touch->getPrevIoUsLocation()-location;
if(_cameraType==CameraType::FreeCamera||_cameraType==CameraType::FirstCamera)
{
Vec3cameraDir;
Vec3cameraRightDir;
//返回世界仿射变换矩阵。矩阵单位是像素。并获取Forward矩阵，参数为目标向量。注意逆世界仿射变换矩阵
_camera->getNodetoWorldtransform().getForwardVector(&cameraDir);
//将返回的矩阵向量规范化
cameraDir.normalize();
//将返回的矩阵向量y轴赋值为0
cameraDir.y=0;
//返回正确的举证向量的世界仿射变化矩阵
_camera->getNodetoWorldtransform().getRightVector(&cameraRightDir);
//向量规范化
cameraRightDir.normalize();
//向量y轴赋值0
cameraRightDir.y=0;
Vec3cameraPos=_camera->getposition3D();
cameraPos+=cameraDir*newPos.y*0.1f;
cameraPos+=cameraRightDir*newPos.x*0.1f;
//重新设置摄像机的3D坐标
_camera->setposition3D(cameraPos);
//如果精灵存在，且相机的类型为第一视角，执行下面代码
if(_sprite3D&&_cameraType==CameraType::FirstCamera)
{
//设置精灵的3D坐标，并保存当前精灵坐标值，用于更新任务运动状态
_sprite3D->setposition3D(Vec3(_camera->getpositionX(),_camera->getpositionZ()));
_targetPos=_sprite3D->getposition3D();
}
}
}
}
//3D精灵移动
voIDCamera3DTestDemo::move3D(floatelapsedtime)
{
if(_sprite3D)
{
//获取当前精灵的3D坐标
Vec3curPos=_sprite3D->getposition3D();
//计算原来坐标与新坐标的向量
Vec3newFaceDir=_targetPos-curPos;
//将y轴赋值为0，并将新向量规范化
newFaceDir.y=0.0f;
newFaceDir.normalize();
//计算偏移
Vec3offset=newFaceDir*25.0f*elapsedtime;
curPos+=offset;
//设置精灵的新坐标
_sprite3D->setposition3D(curPos);
offset.x=offset.x;
offset.z=offset.z;
if(_cameraType==CameraType::ThirdCamera)
{
//如果摄像机的类型为第三视角，同时更新摄像机的3D坐标
Vec3cameraPos=_camera->getposition3D();
cameraPos.x+=offset.x;
cameraPos.z+=offset.z;
_camera->setposition3D(cameraPos);
}
}
}
//判断精灵的状态
voIDCamera3DTestDemo::updateState(floatelapsedtime)
{
if(_sprite3D)
{
Vec3curPos=_sprite3D->getposition3D();
Vec3curFaceDir;
//返回世界仿射变换矩阵。矩阵单位是像素。并获取Forward矩阵，参数为目标向量。注意逆世界仿射变换矩阵
_sprite3D->getNodetoWorldtransform().getForwardVector(&curFaceDir);
curFaceDir=-curFaceDir;
curFaceDir.normalize();
Vec3newFaceDir=_targetPos-curPos;
newFaceDir.y=0.0f;
newFaceDir.normalize();
//计算两个向量的点积，通过返回的值判断精灵运动方向和是否停止
floatcosAngle=std::fabs(Vec3::dot(curFaceDir,newFaceDir)-1.0f);
//返回两个向量的平方距离
floatdist=curPos.distanceSquared(_targetPos);
if(dist<=4.0f)
{
if(cosAngle<=0.01f)
_curState=State_IDle;
else
_curState=State_Rotate;
}
else
{
if(cosAngle>0.01f)
_curState=State_Rotate|State_Move;
else
_curState=State_Move;
}
}
}
voIDCamera3DTestDemo::ontouchesEnded(conststd::vector<touch*>&touches,cocos2d::Event*event)
{
for(auto&item:touches)
{
autotouch=item;
autolocation=touch->getLocationInVIEw();
if(_camera)
{
if(_sprite3D&&_cameraType==CameraType::ThirdCamera&&_bZoomOut==false&&_bZoomIn==false&&_brotateleft==false&&_brotateRight==false)
{
Vec3nearP(location.x,location.y,-1.0f),farP(location.x,1.0f);

autosize=Director::getInstance()->getWinSize();
_camera->unproject(size,&nearP,&nearP);
_camera->unproject(size,&farP,&farP);
Vec3dir(farP-nearP);
floatdist=0.0f;
floatndd=Vec3::dot(Vec3(0,dir);
if(ndd==0)
dist=0.0f;
floatndo=Vec3::dot(Vec3(0,nearP);
dist=(0-ndo)/ndd;
Vec3p=nearP+dist*dir;

if(p.x>100)
p.x=100;
if(p.x<-100)
p.x=-100;
if(p.z>100)
p.z=100;
if(p.z<-100)
p.z=-100;

_targetPos=p;
}
}
}
}
voIDontouchesCancelled(conststd::vector<touch*>&touches,cocos2d::Event*event)
{
}
//更新视图
voIDCamera3DTestDemo::updateCamera(floatfDelta)
{
if(_sprite3D)
{
if(_cameraType==CameraType::ThirdCamera)
{
//摄像机类型为第三视角，判断精灵的运动状态
updateState(fDelta);
//如果精灵正在行走
if(isstate(_curState,State_Move))
{
//使精灵和相机为行走状态
move3D(fDelta);
//如果行走在转身
if(isstate(_curState,State_Rotate))
{
Vec3curPos=_sprite3D->getposition3D();

Vec3newFaceDir=_targetPos-curPos;
newFaceDir.y=0;
newFaceDir.normalize();
Vec3up;
_sprite3D->getNodetoWorldtransform().getUpVector(&up);
up.normalize();
Vec3right;
Vec3::cross(-newFaceDir,up,&right);
right.normalize();
Vec3pos=Vec3(0,0);
Mat4mat;
mat.m[0]=right.x;
mat.m[1]=right.y;
mat.m[2]=right.z;
mat.m[3]=0.0f;

mat.m[4]=up.x;
mat.m[5]=up.y;
mat.m[6]=up.z;
mat.m[7]=0.0f;

mat.m[8]=newFaceDir.x;
mat.m[9]=newFaceDir.y;
mat.m[10]=newFaceDir.z;
mat.m[11]=0.0f;

mat.m[12]=pos.x;
mat.m[13]=pos.y;
mat.m[14]=pos.z;
mat.m[15]=1.0f;
//设置额外的节点变换矩阵
_sprite3D->setAdditionaltransform(&mat);
}
}
}
//如果执行缩小动作
if(_bZoomOut==true)
{
if(_camera)
{
//摄像机类型为第三视角
if(_cameraType==CameraType::ThirdCamera)
{
Vec3lookDir=_camera->getposition3D()-_sprite3D->getposition3D();
Vec3cameraPos=_camera->getposition3D();
//求得相机与精灵的空间距离
if(lookDir.length()<=300)
{
//相机位置增加，且不改变相机与精灵的相对位置
cameraPos+=lookDir.getnormalized();
_camera->setposition3D(cameraPos);
}
}
//如果是自由视角
elseif(_cameraType==CameraType::FreeCamera)
{
Vec3cameraPos=_camera->getposition3D();
if(cameraPos.length()<=300)
{
//相机距离增加
cameraPos+=cameraPos.getnormalized();
_camera->setposition3D(cameraPos);
}
}
}
}
//如果是放大效果
if(_bZoomIn==true)
{
if(_camera)
{
//相机是第三视角
if(_cameraType==CameraType::ThirdCamera)
{
Vec3lookDir=_camera->getposition3D()-_sprite3D->getposition3D();
Vec3cameraPos=_camera->getposition3D();
if(lookDir.length()>=50)
{
//相机与精灵的距离大于50，才会执行下面 *** 作
//相机位置增加
cameraPos-=lookDir.getnormalized();
_camera->setposition3D(cameraPos);
}
}
//如果为自由视角
elseif(_cameraType==CameraType::FreeCamera)
{
Vec3cameraPos=_camera->getposition3D();
if(cameraPos.length()>=50)
{
//相机位置增加
cameraPos-=cameraPos.getnormalized();
_camera->setposition3D(cameraPos);
}
}
}
}
//如果是左转效果
if(_brotateleft==true)
{
//如果相机类型为自由视角和第一视角
if(_cameraType==CameraType::FreeCamera||_cameraType==CameraType::FirstCamera)
{
//y轴增加旋转
Vec3rotation3D=_camera->getRotation3D();
rotation3D.y+=1;
_camera->setRotation3D(rotation3D);
}
}
//如果是右转效果
if(_brotateRight==true)
{
if(_cameraType==CameraType::FreeCamera||_cameraType==CameraType::FirstCamera)
{
//摄像机类型为自由视角和第一视角，y轴减少旋转
Vec3rotation3D=_camera->getRotation3D();
rotation3D.y-=1;
_camera->setRotation3D(rotation3D);
}
}
}
}
//判断精灵的运动状态
boolCamera3DTestDemo::isstate(unsignedintstate,unsignedintbit)const
{
return(state&bit)==bit;
}
//缩小触摸事件
boolCamera3DTestDemo::ontouchesZoomOut(touch*touch,Event*event)
{
autotarget=static_cast<Label*>(event->getCurrentTarget());
//将触摸点的位置转化为节点坐标位置
Vec2locationInNode=target->convertToNodeSpace(touch->getLocation());
Sizes=target->getContentSize();
Rectrect=Rect(0,s.wIDth,s.height);
//如果触摸在节点内
if(rect.containsPoint(locationInNode))
{
_bZoomOut=true;
returntrue;
}
returnfalse;
}
//缩小触摸结束
voIDCamera3DTestDemo::ontouchesZoomOutEnd(touch*touch,Event*event)
{
_bZoomOut=false;
}
//放大触摸事件
boolCamera3DTestDemo::ontouchesZoomIn(touch*touch,Event*event)
{
autotarget=static_cast<Label*>(event->getCurrentTarget());

Vec2locationInNode=target->convertToNodeSpace(touch->getLocation());
Sizes=target->getContentSize();
Rectrect=Rect(0,s.height);
//如果在节点内，设置放大判断值为true
if(rect.containsPoint(locationInNode))
{
_bZoomIn=true;
returntrue;
}
returnfalse;
}
//放大触摸结束
voIDCamera3DTestDemo::ontouchesZoominend(touch*touch,Event*event)
{
_bZoomIn=false;
}
//左转触摸
boolCamera3DTestDemo::ontouchesRotateleft(touch*touch,s.height);
//设置左转触摸为true
if(rect.containsPoint(locationInNode))
{

_brotateleft=true;
returntrue;
}
returnfalse;
}
voIDCamera3DTestDemo::ontouchesRotateleftEnd(touch*touch,Event*event)
{
//左转触摸结束，恢复判断值为false
_brotateleft=false;
}
//右转触摸
boolCamera3DTestDemo::ontouchesRotateRight(touch*touch,s.height);
//设置右转触摸判断值为true；
if(rect.containsPoint(locationInNode))
{
_brotateRight=true;
returntrue;
}
returnfalse;
}
//触摸结束，恢复右转判断触摸值为false
voIDCamera3DTestDemo::ontouchesRotateRightEnd(touch*touch,Event*event)
{
_brotateRight=false;
}
2、使用

在HelloWorld的createScene中，直接创建Camera3DDemo的Layer对象，加入Scene

3、运行效果

总结

以上是内存溢出为你收集整理的Cocos2d-x3.3RC0 Cpp-test分析之Camera3DDemo全部内容，希望文章能够帮你解决Cocos2d-x3.3RC0 Cpp-test分析之Camera3DDemo所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。