盖莫游戏引擎2.1.1的地形小例
代码如下:
1 #include <GEngine/Gaimo.hpp>
2
3 using namespace std;
4 using namespace core;
5 void RotateView(float angle, float x, float y, float z);
6 //! 处理键盘响应
7 void KeyCheck(RefPtr<Input> input);
8 RefPtr<Camera> camera;
9 RefPtr<Text> font;
10 char textbuf[20]="";
11 float yrot=0.0f;
12 float dv=0.0f;
13 int Main()
14 {
15 //! 初始化引擎设备并得到设备指针
16 RefPtr<Device> device = InitDevice("地形测试");
17 //! 得到引擎场景指针
18 RefPtr<SceneManager> scenemanager = device->GetSceneManager();
19 //! 得到引擎资源指针
20 RefPtr<ResourceManager> resourcemanager = device->GetResourceManager();
21 //! 获取图形管理器指针
22 RefPtr<ImageManager> imagemanager = resourcemanager->GetImageManager();
23 //! 得到视频驱动器指针
24 RefPtr<VideoDriver> videodriver = device->GetVideoDriver();
25 font= resourcemanager->GetTextManager()->CreateText("heiti","黑体",16);
26
27 //! 得到地形
28 RefPtr<Terrain> terrain = scenemanager->GetTerrain();
29 //! 载入高程图
30 terrain->LoadHeightMap("..\\terrain\\terrain.raw",1024,16);
31 //! 获取地形图形指针
32 RefPtr<Image> mainimage = imagemanager->CreateObject("mainimage", "..\\terrain\\terrain.bmp");
33 RefPtr<Image> detailimage = imagemanager->CreateObject("detailimage","..\\terrain\\detail.bmp");
34
35 //! 获取纹理管理器
36 RefPtr<TextureManager> texturemanager = resourcemanager->GetTextureManager();
37 //! 获取纹理指针
38 RefPtr<Texture> maintexture = texturemanager->CreateTexture("maintex",mainimage);
39 RefPtr<Texture> detailtexture = texturemanager->CreateTexture("detailtex",detailimage);
40 terrain->LoadTexture(maintexture,detailtexture);
41
42 //! 获取摄像机指针
43 camera = scenemanager->GetCameraManager()->CreateCamera("camera",Vector3f(300,10,300),
44 Vector3f(10,10,0));
45 camera->SetViewPort(Recti(0,0,640,480));
46 camera->SetPerspective(45.0f,640.0f/480.0f,0.1f,600.0f);
47
48 device->GetVideoDriver()->EnableCulling();
49
50 //! 获取雾指针
51 RefPtr<Fog> fog = resourcemanager->GetFog("..\\script//fog.lua","fog");
52 fog->Render();
53
54 Vector3f camera_pos,camera_view;
55 BEGIN_LOOP(device)
56 videodriver->SetClearBuffer(ENGINE_CLEAR_COLOR | ENGINE_CLEAR_DEPTH);
57 camera->Render();
58 terrain->Render();
59
60 KeyCheck(device->GetInput());
61
62 camera_pos = camera->GetPosition();
63
64 sprintf(textbuf,"camerapos:(%f,%f,%f)",camera_pos.x,camera_pos.y,camera_pos.z);
65 font->Render(10,15,textbuf);
66 camera_view = camera->GetView();
67 sprintf(textbuf,"cameraview:(%f,%f,%f)",camera_view.x,camera_view.y,camera_view.z);
68 font->Render(10,35,textbuf);
69 RotateView(yrot,0.0f,1.0f,0.0f);
70 camera->MoveCamera(dv);
71 sprintf(textbuf,"nowheight:%f",terrain->GetAveHeight(camera_pos.x,camera_pos.z));
72 font->Render(10,55,textbuf);
73 camera_pos = camera->GetPosition();
74 camera->SetPosition(Vector3f(camera_pos.x,terrain->GetAveHeight(camera_pos.x,camera_pos.z)+30,camera_pos.z));
75 //! 保持视线水平
76 camera_view = camera->GetView();
77 camera->SetView(Vector3f(camera_view.x,terrain->GetAveHeight(camera_pos.x,camera_pos.z)+30,camera_view.z));
78 dv = 0;
79 END_LOOP(device)
80 return 0;
81 }
代码看似很多
其实很多代码都是简单的取指针操作
下面是贴图
这是盖莫游戏引2.1.1的镜头光功能测试
可以看出盖莫游戏引擎随着开发的不断深入功能越来越强大了
首先上镜头光的代码
////////////////////////////////////////////////////////////
/// 定义引擎镜头光类
////////////////////////////////////////////////////////////
class LensFlare : public Renderable
{
public:
////////////////////////////////////////////////////////////
/// 镜头光构造函数
////////////////////////////////////////////////////////////
LensFlare(){}
////////////////////////////////////////////////////////////
/// 镜头光析构函数
////////////////////////////////////////////////////////////
virtual ~LensFlare(){}
////////////////////////////////////////////////////////////
/// 设置镜头光位置
////////////////////////////////////////////////////////////
virtual void SetLocation(float x,float y,float z) = 0;
////////////////////////////////////////////////////////////
/// 设置主光节点颜色
////////////////////////////////////////////////////////////
virtual void SetMainNodeColor(const Color &maincolor) = 0;
////////////////////////////////////////////////////////////
/// 设置最后一个次光节点颜色
////////////////////////////////////////////////////////////
virtual void SetLastSubNodeColor(const Color &lastcolor) = 0;
////////////////////////////////////////////////////////////
/// 加入主光节点
////////////////////////////////////////////////////////////
virtual bool AddMainNode(float size,RefPtr<Texture> texture) = 0;
////////////////////////////////////////////////////////////
/// 加入次光节点
////////////////////////////////////////////////////////////
virtual bool AddSubNode(float size,float pos,RefPtr<Texture> texture) = 0;
////////////////////////////////////////////////////////////
/// 渲染函数
////////////////////////////////////////////////////////////
virtual void Render() = 0;
DECLARE_OBJECT(LensFlare)
};
可以看出镜头光继承于可渲染对象也就是说我们认为镜头光是一种可渲染对象
它可以被启用也可以使用Frustum做剔除处理
另外需要说明的就是我们可以设置主光和末尾次光的颜色值
其余次光的颜色将使用其颜色的插值
下面是具体的测试代码
移动摄像机则镜头光会随之改变方向
/*!==========================================================================
*
* 盖莫游戏引擎(GaiMo Game Engine)
*
* 版权所有 (C) 2009-2009 成都盖莫软件技术工作室 保留所有权利
* Copyright (C) 成都盖莫软件技术工作室. All Rights Reserved.
*
* 了解更多情况,请访问 http://www.gaimo.net
****************************************************************************/
//! 本例子主要测试盖莫游戏引擎的镜头光功能
//! 2010.04.08
#include <GEngine/Gaimo.hpp>
using namespace core;
int Main()
{
//! 初始化引擎设备并得到设备指针
RefPtr<Device> device = InitDevice("镜头光");
//! 得到引擎场景指针
RefPtr<SceneManager> scenemanager = device->GetSceneManager();
//! 得到引擎资源指针
RefPtr<ResourceManager> resourcemanager = device->GetResourceManager();
//! 获取图形管理器指针
RefPtr<ImageManager> imagemanager = resourcemanager->GetImageManager();
//! 得到视频驱动器指针
RefPtr<VideoDriver> videodriver = device->GetVideoDriver();
//! 获取文件系统指针
RefPtr<FileSystem> filesystem = device->GetFileSystem();
//! 设置文件加载路径
filesystem->AddToSearchPath("..\\image\\lenflare.zip");
//! 获取主光文件
RefPtr<core::ReadFile> mainlenfile = filesystem->OpenRead("hardglow.bmp");
//! 获取次光文件
RefPtr<core::ReadFile> sublenfile = filesystem->OpenRead("halo.bmp");
//! 获取主光图形指针
RefPtr<Image> mainlenimage = imagemanager->CreateObject("mainlenimage",mainlenfile);
//! 获取次光图形指针
RefPtr<Image> sublenimage = imagemanager->CreateObject("sublenimage",sublenfile);
//! 获取纹理管理器
RefPtr<TextureManager> texturemanager = resourcemanager->GetTextureManager();
//! 获取主光纹理
RefPtr<Texture> maintexture = texturemanager->CreateTexture("maintexture",mainlenimage);
//! 获取次光纹理
RefPtr<Texture> subtexture = texturemanager->CreateTexture("subtexture",sublenimage);
//! 获取摄像机指针
RefPtr<Camera> camera = scenemanager->GetCameraManager()->CreateCamera("camera",
Vector3f(),
Vector3f(100,0,0));
camera->SetViewPort(Recti(0,0,640,480));
camera->SetPerspective(45.0f,640.0f/480.0f,0.1f,600.0f);
camera->Render();
//! 获取和设置镜头光参数
RefPtr<LensFlare> lenflare = scenemanager->GetLenFlare();
//! 设置主光位置
lenflare->SetLocation(100,0,0);
//! 设置主光颜色
lenflare->SetMainNodeColor(core::Color(1.0,0.8,0.0,0.3));
//! 设置主光大小和纹理
lenflare->AddMainNode(64,maintexture);
//! 加载次光大小,位置和纹理
for(int i = 0; i < 12; i++)
lenflare->AddSubNode(18*(i%2+1),(i+1)/10.0f,subtexture);
lenflare->SetLastSubNodeColor(core::Color(0.0,0.8,0.5));
BEGIN_LOOP(device)
videodriver->SetClearBuffer(ENGINE_CLEAR_COLOR | ENGINE_CLEAR_DEPTH);
camera->SetPerspective(45.0f,640.0f/480.0f,0.1f,600.0f);
camera->Render();
lenflare->Render();
END_LOOP(device)
return 1;
}
代码很多 但是也很容易理解不需要做什么解释
下面是对应的贴图
这是使用盖莫游戏引擎2.1.1的天空面功能
很简单的
先说天空面描述符(引入这个的目的在于减少很多不相关的函数和代码)
1 ////////////////////////////////////////////////////////
2 /// 定义引擎天空面描述符
3 ////////////////////////////////////////////////////////
4 struct SkyPlaneDesc
5 {
6 SkyPlaneDesc():divisions(32),
7 pradius(1200.0f),
8 aradius(1800.0f),
9 rate(2.5f),
10 axisx(0.0f),
11 axisy(1.0f),
12 axisz(0.0f)
13 {
14 }
15
16 ///////////////////////////////////////////////////////
17 /// 检查描述符是否合法
18 ///////////////////////////////////////////////////////
19 bool IsValid()const
20 {
21 return image &&
22 divisions > 1 &&
23 pradius > 1.0f &&
24 aradius > 1.0f;
25 }
26
27 //! 天空面的图形
28 RefPtr<Image> image;
29 int divisions;
30 float pradius;
31 float aradius;
32 //! 天空转速(角度/秒)
33 float rate;
34 //! 天空旋转轴
35 float axisx;
36 float axisy;
37 float axisz;
38
39 COPY_OBJECT(SkyPlaneDesc)
40 };
其中天空面参数有天空面分割数division
2个半径(面半径和空间半径)
一个天空图形
4个关于旋转的参数
下面是使用盖莫游戏引擎天空面的例子如下所示:
#include <GEngine/Gaimo.hpp>
using namespace std;
using namespace core;
int Main()
{
//! 初始化引擎设备并得到设备指针
RefPtr<Device> device = InitDevice("天空面测试");
//! 得到引擎场景指针
RefPtr<SceneManager> scenemanager = device->GetSceneManager();
//! 得到引擎资源指针
RefPtr<ResourceManager> resourcemanager = device->GetResourceManager();
//! 获取图形管理器指针
RefPtr<ImageManager> imagemanager = resourcemanager->GetImageManager();
//! 得到视频驱动器指针
RefPtr<VideoDriver> videodriver = device->GetVideoDriver();
//! 得到天空图形
RefPtr<core::Image> image = imagemanager->CreateObject("sky","..\\image\\sky\\top.jpg");
//! 得到天空盒指针
SkyPlaneDesc desc;
desc.image = image;
desc.divisions = 32;
desc.pradius = 1200.0f;
desc.aradius = 1800.0f;
RefPtr<Renderable> sky = scenemanager->CreateSkyPlane(desc);
//! 获取摄像机指针
RefPtr<Camera> camera = scenemanager->GetCameraManager()->CreateCamera("camera",
Vector3f(),
Vector3f(100,13,0));
camera->SetViewPort(Recti(0,0,640,480));
camera->SetPerspective(45.0f,640.0f/480.0f,0.1f,600.0f);
//! 获取雾指针
RefPtr<Fog> fog = resourcemanager->GetFog("..\\script//fog.lua","fog");
fog->Render();
BEGIN_LOOP(device)
videodriver->SetClearBuffer(ENGINE_CLEAR_COLOR | ENGINE_CLEAR_DEPTH);
camera->Render();
sky->Render();
END_LOOP(device)
return 0;
}
代码并没有引入地形等其他不相关的东西
只是简单的天空面渲染
代码虽然很多但是核心无非就是:
1 //! 得到天空盒指针
2 SkyPlaneDesc desc;
3 desc.image = image;
4 desc.divisions = 32;
5 desc.pradius = 1200.0f;
6 desc.aradius = 1800.0f;
7 RefPtr<Renderable> sky = scenemanager->CreateSkyPlane(desc);
8
9 //! 获取摄像机指针
10 RefPtr<Camera> camera = scenemanager->GetCameraManager()->CreateCamera("camera",
11 Vector3f(),
12 Vector3f(100,13,0));
在循环过程中无非就是她的Render了
下面是贴图:
t天真的是蔚蓝蔚蓝的
/*!==========================================================================
*
* 盖莫游戏引擎(GaiMo Game Engine)
*
* 版权所有 (C) 2009-2009 成都盖莫软件技术工作室 保留所有权利
* Copyright (C) 成都盖莫软件技术工作室. All Rights Reserved.
*
* 了解更多情况,请访问 http://www.gaimo.net
****************************************************************************/
//! 本例子主要测试盖莫游戏引擎的线程渲染和绘制基本2d几何对象
//! 2010.04.08
#include <GEngine/Gaimo.hpp>
using namespace core;
using namespace ZThread;
Color color1(0.0f,0.5f,0.5f),color2(0.0f,1.0f,0.0f);
Color color3(1.0f,0.0f,0.0f),color4(1.0f,0.0f,1.0f);
Color color5(1.0f,1.0f,0.0f),color6(0.0f,1.0f,1.0f);
RefPtr<Device> device;
RefPtr<VideoDriver> videodriver;
void Render(bool flag);
//! 线程渲染类
class RenderThread : public Runnable
{
public:
RenderThread():flag(false){}
void run(){Render(flag);}
void Stop(){flag = true;}
private:
bool flag;
};
int Main()
{
device = core::InitDevice("线程渲染");
videodriver = device->GetVideoDriver();
videodriver->DetachRender();
RenderThread* render;
try
{
render = new RenderThread;
ZThread::Thread thread(render);
render->Stop();
}
catch(Synchronization_Exception& e)
{
std::cout<<e.what()<<std::endl;
}
BEGIN_LOOP(device)
END_LOOP(device)
return 1;
}
void Render(bool flag)
{
//! 获取引擎资源管理器
core::RefPtr<core::ResourceManager> resmgr = device->GetResourceManager();
videodriver->AttachRender();
videodriver->Ortho2D();
videodriver->SetClearColor(core::Color::Blue);
BEGIN_LOOP(device)
videodriver->SetClearBuffer(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
//! 绘制矩形
videodriver->SetColor(color1);
videodriver->FillRect(100,120,50,50);
//! 绘制矩形
videodriver->SetColor(color2);
videodriver->DrawRect(100,180,50,50);
//! 绘制网格
videodriver->SetColor(color3);
videodriver->DrawGrid(Point(10,10),Point(20,20),Point(5,5));
//! 绘制变色矩形
//core::Render::DrawRaisedRectangle(libmath::Rect<float>(250,50,50,50),color5,color6);
//! 绘制三角形
videodriver->SetColor(color4);
//videodriver->DrawTriangle(Point(200,180),Point(200,270),Point(290,110),true);
//! 绘制点
videodriver->DrawPoint(Point(200,120));
RETURN_LOOP(flag,true)
END_LOOP(device);
}
这是使用盖莫游戏引擎2.1.1线程渲染的例子
由于比较简单这里就不提图片了(免得浪费空间)
这是使用盖莫游戏引擎2.1.1做的简单球面映射
比较简单的不说什么
献上贴图:
再上代码
1 using namespace std;
2 using namespace core;
3
4 int main(int argc, char **argv)
5 {
6 //! 初始化引擎设备并得到设备指针
7 RefPtr<Device> device = core::InitDevice("球面映射");
8 //! 得到引擎场景指针
9 RefPtr<SceneManager> scenemanager = device->GetSceneManager();
10 //! 得到引擎资源指针
11 RefPtr<ResourceManager> resourcemanager = device->GetResourceManager();
12 //! 获取引擎纹理管理器指针
13 RefPtr<TextureManager> texturemanager = resourcemanager->GetTextureManager();
14 //! 获取引擎图形管理器
15 RefPtr<ImageManager> imagemanager = resourcemanager->GetImageManager();
16 //! 获取引擎视频驱动器
17 RefPtr<VideoDriver> videodriver = device->GetVideoDriver();
18
19 //! 得到图形和其纹理
20 core::RefPtr<Image> image1 = imagemanager->CreateObject("background","..\\image//spheremap//tree.jpg");
21 core::RefPtr<Texture> background = texturemanager->CreateObject("background",image1);
22
23 core::RefPtr<Image> image2 = imagemanager->CreateObject("reflect","..\\image//spheremap//tree1.jpg");
24 core::RefPtr<Texture> reflect = texturemanager->CreateSphereMap("reflect",image2);
25
26 background->Generate();
27 reflect->Generate();
28
29 //! 获取全局摄像机,设置摄像机参数
30 core::RefPtr<core::Camera> camera = scenemanager->GetActiveCamera();
31 camera->SetPosition(Vector3f(0,0,30));
32 camera->SetView(Vector3f(0,0,0));
33 camera->SetDirection(Vector3f(0,1,0));
34 camera->SetViewPort(Recti(0,0,640,480));
35 camera->SetPerspective(50.0f,640.0f/480.0f,0.1f,1000.0f);
36 videodriver->EnableCulling();
37
38 BEGIN_LOOP(device)
39 videodriver->SetClearBuffer(ENGINE_CLEAR_COLOR | ENGINE_CLEAR_DEPTH);
40 videodriver->SetClearColor(core::Color::Blue);
41 camera->Render();
42
43 background->AttachRenderTarget();
44 glBegin(GL_QUADS);
45 glNormal3f( 0.0f, 0.0f, 1.0f);
46 glTexCoord2f(0.0f, 0.0f); glVertex3f(-13.0f, -12.0f, 10.0f);
47 glTexCoord2f(1.0f, 0.0f); glVertex3f( 13.0f, -12.0f, 10.0f);
48 glTexCoord2f(1.0f, 1.0f); glVertex3f( 13.0f, 12.0f, 10.0f);
49 glTexCoord2f(0.0f, 1.0f); glVertex3f(-13.0f, 12.0f, 10.0f);
50 glEnd();
51
52 reflect->AttachRenderTarget();
53 videodriver->RenderSphere(12,32,32);
54 videodriver->RenderSphere(9,32,32);
55 videodriver->RenderSphere(6,32,32);
56 reflect->Destroy();
57 END_LOOP(device)
58
59 return 0;
60 }
题外话:截止目前引擎支持2d纹理,球面映射和立方体纹理
其它相关的映射和纹理会陆续加入
摘要: 今天突然想给引擎加入一个新的功能那就是使用多线程载入资源如果游戏资源过多,而只采用一个线程载入资源显然是不够的
所以就加入这个功能吧设计代码有:1.资源基类
1 //////////////////////////////////////////////////////////// 2 /// 定义资源基类 3&nb...
阅读全文
这是盖莫游戏引擎的立方体纹理一例
代码如下:
1 //! 2010.03.03
2 /////////////////////////////////////////////////////
3 /// 盖莫游戏引擎的立方体绘制
4 /////////////////////////////////////////////////////
5 //! 测试立方体绘制函数,矩阵,输入输出
6 //! 按键f1,f2,f3旋转立方体
7 #include <GEngine/Gaimo.hpp>
8
9 #define BOX_SIDE (12.0)
10 using namespace std;
11 using namespace core;
12 Matrix4f mat;
13
14 //! 处理鼠标响应
15 void MouseCheck(core::RefPtr<core::Input> input);
16
17 int main(int argc, char **argv)
18 {
19 //! 初始化引擎设备并得到设备指针
20 RefPtr<Device> device = core::InitDevice("立方体纹理");
21 //! 得到引擎场景指针
22 RefPtr<SceneManager> scenemanager = device->GetSceneManager();
23 //! 得到引擎资源指针
24 RefPtr<ResourceManager> resourcemanager = device->GetResourceManager();
25 //! 获取引擎纹理管理器指针
26 RefPtr<TextureManager> texturemanager = resourcemanager->GetTextureManager();
27 //! 获取引擎图形管理器
28 RefPtr<ImageManager> imagemanager = resourcemanager->GetImageManager();
29 //! 获取引擎视频驱动器
30 RefPtr<VideoDriver> videodriver = device->GetVideoDriver();
31 //! 获取文件系统指针
32 RefPtr<FileSystem> filesystem = device->GetFileSystem();
33 filesystem->AddToSearchPath("..\\image//cubemap.zip");
34
35 //! 得到tile图形和其纹理
36 core::RefPtr<Image> image1 = imagemanager->CreateObject("cube1",filesystem->OpenRead("cm_front.png"));
37 CHECK_PTR_PRINT(image1,"bad image1");
38 core::RefPtr<Image> image2 = imagemanager->CreateObject("cube2",filesystem->OpenRead("cm_back.png"));
39 CHECK_PTR_PRINT(image2,"bad image2");
40 core::RefPtr<Image> image3 = imagemanager->CreateObject("cube3",filesystem->OpenRead("cm_left.png"));
41 CHECK_PTR_PRINT(image3,"bad image3");
42 core::RefPtr<Image> image4 = imagemanager->CreateObject("cube4",filesystem->OpenRead("cm_right.png"));
43 CHECK_PTR_PRINT(image4,"bad image4");
44 core::RefPtr<Image> image5 = imagemanager->CreateObject("cube5",filesystem->OpenRead("cm_top.png"));
45 CHECK_PTR_PRINT(image5,"bad image5");
46 core::RefPtr<Image> image6 = imagemanager->CreateObject("cube6",filesystem->OpenRead("cm_bottom.png"));
47 CHECK_PTR_PRINT(image6,"bad image6");
48 core::RefPtr<Texture> cubemap = texturemanager->CreateCubeMap("cubemap",image1,image2,image3,image4,image5,image6);
49 cubemap->Generate();
50
51 //! 获取全局摄像机,设置摄像机参数
52 core::RefPtr<core::Camera> camera = scenemanager->GetActiveCamera();
53 camera->SetPosition(Vector3f(20,20,20));
54 camera->SetView(Vector3f(0,0,0));
55 camera->SetDirection(Vector3f(0,1,0));
56
57 camera->SetViewPort(Recti(0,0,640,480));
58 camera->SetPerspective(50.0f,640.0f/480.0f,0.1f,1000.0f);
59 videodriver->EnableCulling();
60
61 float sides[] = {BOX_SIDE,BOX_SIDE,BOX_SIDE};
62 float pos[] = {0,0,0};
63 BEGIN_LOOP(device)
64 videodriver->SetClearBuffer(ENGINE_CLEAR_COLOR | ENGINE_CLEAR_DEPTH);
65 videodriver->SetClearColor(core::Color::Blue);
66 camera->Render();
67 MouseCheck(device->GetInput());
68 cubemap->AttachRenderTarget();
69 videodriver->RenderCube(pos,mat.ptr(),sides);
70 END_LOOP(device)
71
72 return 0;
73 }
74
75 //! 处理鼠标响应
76 void MouseCheck(core::RefPtr<core::Input> input)
77 {
78 if(input->IsPressedKey(KEY_F1))
79 {
80 mat*=mat.Rotate((rand()%200)/1200.0f,1,0,0);
81 }
82 else if(input->IsPressedKey(KEY_F2))
83 {
84 mat*=mat.Rotate((rand()%200)/1200.0f,0,1,0);
85 }
86 else if(input->IsPressedKey(KEY_F3))
87 {
88 mat*=mat.Rotate((rand()%200)/1200.0f,0,0,1);
89 }
90 }
91
92
93
具体的使用方法就是从设备指针中获取资源管理器指针
然后从资源管理器获取纹理管理器指针
之后调用CreateCubeMap();传入6个图形指针即可
之后调用成员函数Generate函数
在使用的时候调用AttachRenderTarget绑定当前纹理即可使用很方便吧
下面是具体的贴图:
根据Loki的CheckReturn所说:
1 /// C++ provides no mechanism within the language itself to force code to
2 /// check the return value from a function call. This simple class provides
3 /// a mechanism by which programmers can force calling functions to check the
4 /// return value. Or at least make them consciously choose to disregard the
5 /// return value. If the calling function fails to use or store the return
6 /// value, the destructor calls the OnError policy.
c++并没有提供内置的机制去强制检测函数返回值.
loki提供的简单类CheckReturn提供了简单的机制去保证函数检测返回值
当然可以使用定制的模板制定没有检测函数返回值时的处理策略
1.CheckReturn的处理策略(内置)
1 template<class T>
2 struct IgnoreReturnValue
3 {
4 static void run(const T&)
5 {
6 /// Do nothing at all.
7 }
8 };
9
10 template<class T>
11 struct ThrowTheValue
12 {
13 static void run(const T & value )
14 {
15 throw value;
16 }
17 };
18
19 template<class T>
20 struct ThrowLogicError
21 {
22 static void run( const T & )
23 {
24 throw ::std::logic_error( "CheckReturn: return value was not checked.\n" );
25 }
26 };
27
28 template<class T>
29 struct TriggerAssert
30 {
31 static void run(const T&)
32 {
33 assert( 0 );
34 }
35 };
36
37 template<class T>
38 struct FprintfStderr
39 {
40 static void run(const T&)
41 {
42 fprintf(stderr, "CheckReturn: return value was not checked.\n");
43 }
44 };
可以看出对于软件开发
在release代码中我们可以使用IgnoreReturnValue
在debug代码中我们可以使用ThrowLogicError来显示没有检测函数返回值
在CheckReturn类的实现如下:
1 template < class Value , template<class> class OnError = TriggerAssert >
2 class CheckReturn
3 {
4 public:
5
6 /// Conversion constructor changes Value type to CheckReturn type.
7 inline CheckReturn( const Value & value ) :
8 m_value( value ), m_checked( false ) {}
9
10 /// Copy-constructor allows functions to call another function within the
11 /// return statement. The other CheckReturn's m_checked flag is set since
12 /// its duty has been passed to the m_checked flag in this one.
13 inline CheckReturn( const CheckReturn & that ) :
14 m_value( that.m_value ), m_checked( false )
15 { that.m_checked = true; }
16
17 /// Destructor checks if return value was used.
18 inline ~CheckReturn( void )
19 {
20 // If m_checked is false, then a function failed to check the
21 // return value from a function call.
22 if (!m_checked)
23 OnError<Value>::run(m_value);
24 }
25
26 /// Conversion operator changes CheckReturn back to Value type.
27 inline operator Value ( void )
28 {
29 m_checked = true;
30 return m_value;
31 }
32
33 private:
34 /// Default constructor not implemented.
35 CheckReturn( void );
36
37 /// Copy-assignment operator not implemented.
38 CheckReturn & operator = ( const CheckReturn & that );
39
40 /// Copy of returned value.
41 Value m_value;
42
43 /// Flag for whether calling function checked return value yet.
44 mutable bool m_checked;
45 };
首先它提供了一个bool变量来存储是否检查了函数返回值
如果CheckReturn r(value);r()一下则说明检查了函数返回值(非常有利于软件测试)
当然检测返回值的时期发生在其析构过程中
另外该类不允许对象的默认构造
下面给出一个简单的使用例子:
1 #include <loki/CheckReturn.h>
2
3 using namespace std;
4 using namespace Loki;
5
6 //#define G_DEBUG
7
8 #ifndef G_DEBUG
9 typedef CheckReturn<int,FprintfStderr> CheckInt;
10 #else
11 typedef CheckReturn<int,IgnoreReturnValue> CheckInt;
12 #endif
13
14 int main(int argc, char *argv[])
15 {
16 int i = 0;
17 {
18 CheckInt check(i);
19 }
20
21 system("PAUSE");
22 return EXIT_SUCCESS;
23 }
如果我们定义了宏G_DEBUG则表明这是debug模式
附注:以前早早就接触到了loki,以前也翻过c++设计新思维
不过想起来还是看其源码和其自带的使用例子
关于loki库我想写多篇分析其库的短小精悍的例子
摘要: 这是盖莫引擎AABB3的设计 主要参考了几个引擎代码这个并没有太多需要说明的唯一要说的就是使用给定矩阵变换AABB3代码如下:
Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1 //////////////////...
阅读全文
引擎的场景这块我一直是写了,删除,再写,一直感觉不太满意
本想着做成irr那种父节点-子场景的形式
一是感觉过于复杂
二则都这个不是理解的很到位
所以感觉写还是简单吧
修改起来也比较容易
具体的Renderable如下:
1 ///////////////////////////////////////////////////////
2 /// 定义引擎可渲染对象基类
3 ///////////////////////////////////////////////////////
4 class Renderable : public Object
5 {
6 public:
7 ///////////////////////////////////////////////////////
8 /// 构造,析构可渲染对象
9 ///////////////////////////////////////////////////////
10 Renderable();
11 Renderable(bool visible,bool auto_culling = false):
12 visible(visible),
13 auto_culling(auto_culling)
14 {
15 }
16 virtual ~Renderable(){}
17 public:
18 ///////////////////////////////////////////////////////
19 /// 设置,获取是否渲染(显示)场景
20 ///////////////////////////////////////////////////////
21 void SetVisible(bool visible){this->visible = visible;}
22 void EnableVisible(){visible = true;}
23 void DisableVisible(){visible = false;}
24 bool IsVisible()const{return visible;}
25
26 ///////////////////////////////////////////////////////
27 /// 设置,获取是否自动调用视锥体剔除
28 ///////////////////////////////////////////////////////
29 void SetAutoCulling(bool auto_cull){this->auto_culling = auto_cull;}
30 bool IsAutoCulling()const{return auto_culling;}
31
32 ///////////////////////////////////////////////////////
33 /// 设置,获取对象的平移
34 ///////////////////////////////////////////////////////
35 /*void SetTranslate(const Vector3f &offset){this->offset = offset;}
36 Vector3f GetTranslate()const{return offset;}
37
38 ///////////////////////////////////////////////////////
39 /// 设置,获取对象的平旋转(角度)
40 ///////////////////////////////////////////////////////
41 void SetRotate(const Vector3f &rot){this->rotate = rot;}
42 Vector3f GetRotate()const{return rotate;}
43
44 ///////////////////////////////////////////////////////
45 /// 设置,获取对象的缩放
46 ///////////////////////////////////////////////////////
47 void SetScale(const Vector3f &scale){this->scale = scale;}
48 Vector3f GetScale()const{return scale;}*/
49
50 ///////////////////////////////////////////////////////
51 /// 获取可渲染物体是否在视锥体内
52 ///////////////////////////////////////////////////////
53 virtual bool IsInFrustum()const{return true;}
54
55 ///////////////////////////////////////////////////////
56 /// 渲染函数
57 ///////////////////////////////////////////////////////
58 //! virtual void BeginRender() = 0;
59 virtual void Render() = 0;
60 //! virtual void AfterRender() = 0;
61 protected:
62 bool visible;
63 bool auto_culling;
64 //Vector3f offset;
65 //Vector3f scale;
66 //Vector3f rotate;
67
68 DECLARE_OBJECT(Renderable)
69 };
70
Renderable是一切可渲染对象的基类
它提供了以下几个功能:
1.渲染
2.检测对象是否在视锥体内(默认总是true)
3.设置对象的可视状态和检索
4.设置是否自动调用自剔除功能
然后在具体的场景对象中可以处理如下:
1.如果是天空盒之类则其总是视锥体内的
2.如果是光材质雾之类的对象则其可显示变为启用
3.如果对象为md2模型之类则从Renderable下面再弄一个子类