从零开始的openGL--cs游戏（4）GameObject类 ，Component类，Transform类

最新推荐文章于 2024-06-07 20:11:45 发布
最新推荐文章于 2024-06-07 20:11:45 发布
阅读量291 收藏
点赞数
分类专栏： OpenGL 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41041725/article/details/121863055
版权

GameObject类 ，所有游戏中的物体都继承此类

#ifndef GameObject_H
#define GameObject_H
#include "Transform.h"
#include <map>
#include <string>
#include "Component.h"
using namespace std;
class GameObject
{
public:
	GameObject(string name, Transform* parent);
	Transform* transform;
	map<string, Component*> Components;
	virtual void Update();
	virtual void LateUpdate();
	virtual void Render();
	string name;

	template<typename T>
	T* AddComponent()
	{
		T* t = new T(this);
		Component* component = &(*t);
		string name = typeid(T).name();
		auto find = Components.find(name);
		if (find != Components.end())
		{
			find->second->SetNext(component);
		}
		else
		{
			Components[name] = component;
		}
		return t;
	}
	template<typename T>
	T* GetComponent()
	{
		string name = typeid(T).name();
		auto find = Components.find(name);
		if (find != Components.end())
		{
			return find->second;
		}
		return nullptr;
	}
};
#endif
#include "GameObject.h"

GameObject::GameObject(string name, Transform* parent)
{
    this->name = name;
    transform = new Transform(glm::vec3(0.0f), glm::vec3(0.0f), glm::vec3(1.0f),parent);
    transform->SetGameObject(this);
}

void GameObject::Update()
{
    map<string, Component*>::iterator  iter;
    for (iter = Components.begin(); iter != Components.end(); iter++) {
        iter->second->Update();
    }

}

void GameObject::LateUpdate()
{
    map<string, Component*>::iterator  iter;
    for (iter = Components.begin(); iter != Components.end(); iter++) {
        iter->second->LateUpdate();
    }
}

void GameObject::Render()
{
    map<string, Component*>::iterator  iter;
    for (iter = Components.begin(); iter != Components.end(); iter++) {
        iter->second->Render();
    }
}

Component类，必须附加到gameobject中

#ifndef Component_H
#define Component_H
#include <string>
using namespace std;
class GameObject;
class Component
{
public:
	virtual string GetName();
	GameObject* gameObject;
	Component();
	Component(GameObject* gameObject);
	void SetNext(Component* next);
	virtual void Update();
	virtual void LateUpdate();
	virtual void Render();
	~Component();
private:
	Component* _next;
	string _name;
protected:
	void SetName(string name);

};
#endif


---------------------
#include "Component.h"

#include "Component.h"
#include "GameObject.h"

string Component::GetName()
{
	return _name;
}

Component::Component()
{
	_next = nullptr;
}

Component::Component(GameObject* gameObject)
{
	this->gameObject = gameObject;
	_next = nullptr;
}

void Component::SetNext(Component* next)
{
	if (_next == nullptr)
		_next = next;
	else
		_next->SetNext(next);
}

void Component::Update()
{
	if (_next != nullptr)
		_next->Update();
}

void Component::LateUpdate()
{
	if (_next != nullptr)
		_next->LateUpdate();
}

void Component::Render()
{
	if (_next != nullptr)
		_next->Render();
}

Component::~Component()
{
	;
}

void Component::SetName(string name)
{
	_name = name;
}

Transform类，gameobject的基础属性。

#ifndef Transform_H
#define Transform_H
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <vector>
using namespace std;
const float PI = 3.1415926536f;
class GameObject;
class Transform
{
public:
	static Transform* Root;
	GameObject* gameObject;
	Transform* parent;
	vector<Transform*> childs;

	glm::vec3 localPosition;
	glm::vec3 localXYZAngle;
	glm::vec3 localScale;

	glm::mat4 worldTransformMat;

	

	Transform(glm::vec3 localPosition = glm::vec3(0.0f), glm::vec3 localXYZAngle = glm::vec3(0.0f), glm::vec3 localScale = glm::vec3(1.0f), Transform* parent = Transform::Root);
	glm::mat4 GetLocalTransformMat();
	glm::mat4 SetWorldTransformMat();
	glm::mat4 GetWorldToLocalMat();
	glm::vec3 GetWordPosition();


	glm::mat4 GetLocalPositionMat();
	glm::mat4 GetLocalRotateMat(glm::mat4 model);
	glm::mat4 GetLocalScaleMat(glm::mat4 model);

	glm::vec3 GetWordForward();
	glm::vec3 GetWordRight();
	glm::vec3 GetWordUp();
	glm::vec3 GetLocalForward();
	glm::vec3 GetLocalRight();
	glm::vec3 GetLocalUp();

	void SetLocalForward(glm::vec3 forward);
	void SetLocalRight(glm::vec3 right);
	void SetLocalUp(glm::vec3 up);

	/*void SetForwardUp(glm::vec3 forward , glm::vec3 up);
	void SetRightUP(glm::vec3 right, glm::vec3 up);
	void SetForwardRight(glm::vec3 forward , glm::vec3 right);*/

	glm::mat4 WorldMatToLocal(glm::mat4 worldMat);
	glm::vec3 WorldDirToLocal(glm::vec3 worldVec);
	glm::vec3 LocalDirToWorld(glm::vec3 LocalVec);
	void Updete();
	void LateUpdate();
	void Render();
	void SetGameObject(GameObject* go);


private:
	glm::vec3 m_forward; //Z
	glm::vec3 m_right; //X
	glm::vec3 m_up; //Y
};
#endif


-------------------

#include "Transform.h"
#include "GameObject.h"
#include <glm/gtc/quaternion.hpp>


Transform::Transform(glm::vec3 localPosition, glm::vec3 localXYZAngle, glm::vec3 localScale, Transform* parent) :
	localPosition(localPosition), localXYZAngle(localXYZAngle), localScale(localScale), parent(parent)
{
	m_forward = glm::vec3(0.0f, 0.0f, 1.0f);
	m_up = glm::vec3(0.0f, 1.0f, 0.0f);
	m_right = glm::vec3(1.0f, 0.0f, 0.0f);
	if (parent != nullptr)
	{
		parent->childs.push_back(this);
		worldTransformMat = parent->worldTransformMat;
	}
	else
	{
		worldTransformMat = glm::mat4(1.0f);
	}
}
Transform* Transform::Root = nullptr;

glm::mat4 Transform::GetLocalTransformMat()
{
	/*glm::mat4 model(1.0f);
	model = glm::translate(model, localPosition);
	model = localXYZAngle.z == 0.0f ? model : glm::rotate(model, localXYZAngle.z, m_forward);
	model = localXYZAngle.y == 0.0f ? model : glm::rotate(model, localXYZAngle.y, m_up);
	model = localXYZAngle.x == 0.0f ? model : glm::rotate(model, localXYZAngle.x, m_right);
	model = glm::scale(model, localScale);
	return model;*/
	return GetLocalScaleMat(GetLocalRotateMat(GetLocalPositionMat()));
}

glm::mat4 Transform::SetWorldTransformMat()
{
	glm::mat4 worldTransformMat = GetLocalTransformMat();
	if (this != Transform::Root && parent != Transform::Root)
		worldTransformMat = parent->worldTransformMat * worldTransformMat;
	this->worldTransformMat = worldTransformMat;
	return worldTransformMat;
}

glm::mat4 Transform::GetWorldToLocalMat()
{
	return glm::inverse(worldTransformMat);
}

glm::vec3 Transform::GetWordPosition()
{
	glm::vec3 worldP =  glm::vec3(parent->worldTransformMat * glm::vec4(localPosition ,1.0f));
	return worldP;
}

glm::mat4 Transform::GetLocalPositionMat()
{
	glm::mat4 model(1.0f);
	return glm::translate(model, localPosition);
}

glm::mat4 Transform::GetLocalRotateMat(glm::mat4 model)
{
	//先旋转y再x再z
	/*glm::quat Rotation = glm::quat(1.0f, glm::radians(localXYZAngle.x), glm::radians(localXYZAngle.y), glm::radians(localXYZAngle.z));
	glm::mat4 RotationM = glm::mat4_cast(Rotation);*/
	m_forward = glm::vec3(0.0f, 0.0f, 1.0f);
	m_up = glm::vec3(0.0f, 1.0f, 0.0f);
	m_right = glm::vec3(1.0f, 0.0f, 0.0f);
	auto a = glm::angleAxis(glm::radians(localXYZAngle.y),m_up);
	m_forward = a * m_forward;
	m_right = a * m_right;
	auto b = glm::angleAxis(glm::radians(localXYZAngle.x), m_right);
	m_up = b * m_up; 
	m_forward = b * m_forward;
	auto c = glm::angleAxis(glm::radians(localXYZAngle.z), m_forward);
	m_up = c * m_up;
	m_right = c * m_right;
	/*model = localXYZAngle.z == 0.0f ? model : glm::rotate(model, localXYZAngle.z ,m_forward);
	model = localXYZAngle.y == 0.0f ? model : glm::rotate(model, localXYZAngle.y, m_up);
	model = localXYZAngle.x == 0.0f ? model : glm::rotate(model, localXYZAngle.x, m_right);*/
	return glm::mat4_cast(c*b*a) * model;
}

glm::mat4 Transform::GetLocalScaleMat(glm::mat4 model)
{
	return glm::scale(model, localScale);
}

glm::vec3 Transform::GetWordForward()
{
	return LocalDirToWorld(glm::vec3(0.0f,0.0f,1.0f));
	//return LocalDirToWorld(GetLocalForward());
}

glm::vec3 Transform::GetWordRight()
{
	return LocalDirToWorld(glm::vec3(1.0f, 0.0f, 0.0f));
	//return LocalDirToWorld(GetLocalRight());
}

glm::vec3 Transform::GetWordUp()
{
	return LocalDirToWorld(glm::vec3(0.0f, 1.0f, 0.0f));
	//return LocalDirToWorld(GetLocalUp());
}

glm::vec3 Transform::GetLocalForward()
{
	/*glm::vec3 f(0.0f);
	f.y = sin(glm::radians(localXYZAngle.x));
	float k = sqrtf(1 - f.y * f.y);
	f.x = k * sin(glm::radians(localXYZAngle.y));
	f.z = k * cos(glm::radians(localXYZAngle.y));
	return glm::normalize(f);*/
	return m_forward;
}

glm::vec3 Transform::GetLocalRight()
{
	/*glm::vec3 f(0.0f);
	f.y = sin(-localXYZAngle.z);
	float k = sqrtf(1 - f.y * f.y);
	f.x = k * cos(localXYZAngle.y);
	f.z = k * sin(localXYZAngle.y);
	return glm::normalize(f);*/
	return m_right;
}

glm::vec3 Transform::GetLocalUp()
{
	/*glm::vec3 f(0.0f);
	f.z = sin(-localXYZAngle.x);
	float k = sqrtf(1 - f.z * f.z);
	f.x = k * sin(localXYZAngle.z);
	f.z = k * cos(localXYZAngle.z);
	return glm::normalize(f);*/
	return m_up;
}

void Transform::SetLocalForward(glm::vec3 forward)
{
	localXYZAngle.y = atan2f(-forward.x, forward.z) * (180.f / PI);
	localXYZAngle.x = atan2f(forward.y, forward.x * forward.x + forward.z * forward.z) * (180.f / PI);
	localXYZAngle.z = 0.0f;
}

void Transform::SetLocalRight(glm::vec3 right)
{
	localXYZAngle.y = atan2f(right.z, right.x) * (180.f / PI);
	localXYZAngle.z = atan2f(-right.y, right.x * right.x + right.z * right.z) * (180.f / PI);
	localXYZAngle.x = 0.0f;
}

void Transform::SetLocalUp(glm::vec3 up)
{
	localXYZAngle.z = atan2f(up.x, up.y) * (180.f / PI);
	localXYZAngle.x = atan2f(-up.z, up.x * up.x + up.y * up.y) * (180.f / PI);
	localXYZAngle.y = 0.0f;
}

glm::mat4 Transform::WorldMatToLocal(glm::mat4 worldMat)
{
	return GetWorldToLocalMat() * worldMat;
}

glm::vec3 Transform::WorldDirToLocal(glm::vec3 worldVec)
{
	glm::mat3 worldToLocalMat(glm::transpose(GetWorldToLocalMat()));
	glm::vec3 localVec3 = glm::inverse(worldToLocalMat) * worldVec;
	return glm::normalize(localVec3);
}

glm::vec3 Transform::LocalDirToWorld(glm::vec3 LocalVec)
{
	glm::mat3 worldToObject(GetWorldToLocalMat());
	glm::vec3 worldVec = glm::transpose(worldToObject) * LocalVec;
	return glm::normalize(worldVec);
}

void Transform::Updete()
{
	SetWorldTransformMat();
	gameObject->Update();
	for (vector<Transform*>::iterator iter = childs.begin(); iter != childs.end(); iter++)
	{
		(*iter)->Updete();
	}
}

void Transform::LateUpdate()
{
	gameObject->LateUpdate();
	for (vector<Transform*>::iterator iter = childs.begin(); iter != childs.end(); iter++)
	{
		(*iter)->LateUpdate();
	}
}

void Transform::Render()
{
	gameObject->Render();
	for (vector<Transform*>::iterator iter = childs.begin(); iter != childs.end(); iter++)
	{
		(*iter)->Render();
	}
}

void Transform::SetGameObject(GameObject* go)
{
	gameObject = go;
}
ロ畏蓅ㄧ氓
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenGL入门教程
xiangzhihong8的专栏
12-03 11万+
概述 OpenGL OpenGL是渲染2D、3D矢量图形硬件的一种软件接口。本质上说，它是一个3D图形和模型库，具有高度的可移植性，并且具有非常快的渲染速度。OpenGL并不是一种语言，而是更像一个C运行时函数库。它提供了一些预包装的功能，帮助开发人员编写功能强大的三维应用程序。 OpenGL可以再多种操作系统平台上运行，例如各种版本的Windows、UNIX/Linux、Mac OS 和 OS/...
Unity-support-Arabic-language-gameobject：Gameobject上免费支持统一教程的阿拉伯语
02-06
Unity-support-Arabic-language-gameobject：Gameobject上免费支持统一教程的阿拉伯语
OpenGL基础篇之渲染过程
梦翼-的博客
01-12 3105
背景 OpenGL是一种跨平台的图像渲染方式，这边主要介绍一下OpenGL在android上的应用，即OpenGLES，之所以用它来渲染是因为以往的c++渲染方式比较慢而且占用较大内存，使用OpenGL可以实现实时渲染，而且可以充分利用GPU的内存。   OpenGL数据传递 要使用OpenGL进行渲染，第一步就是怎样把数据放到GPU里面了，利用IPC这样的数据传递是不现实的，...
Unity的GameObject类与Transform类
yaohuiyaoo的博客
11-07 2195
1.GameObject:一个类类型，所有游戏物体都是这个类型的对象 2.gameObject：一个对象，指的是这个脚本所附着的游戏物件 当前游戏对象的实例 3.Transfrom:是一个类，用来描述物体的大小位置旋转等等信息 4.Transfrom是Transfrom的对象，依附再每一个物件 也是当前游戏对象的一个组件（每一个对象都有这个组件）。当前游戏对象的组件 5.gameObject.transfrom=this.transfrom=transfrom获取当前游戏对象的组件 6.Transfro.
Transform与GameObject的区别于用法
宁静致远
07-31 7549
点击打开链接 transform和gameboject还真像一对双胞胎，初学者很容易混淆了，那么怎么区分这两者呢？ 首先，gameobject是一个父集，派生自object。而transform只是gameboject的子集，它包含如位置、旋转、缩放信息，它派生自component，属于组件。 那么具体的用法呢？gameobject.find用来获取场景中那个我们需要查找的对
关于AddComponent的泛型方法
mingtingjian的博客
11-29 5695
因为游戏中经常需要创建GameObject物体，而且需要绑定一些脚本，特别是UI部分，每个Panel都需要绑定管理脚本，所以就写了这么个简单方法，特别方便了创建的GameObject绑定脚本。 /// /// 创建UI /// /// The panel. /// Panel name. /// The 1st type parameter. public static T
一款基于cocos2d-x开发的一款横版卷轴类游戏
03-23
GameObject 游戏对象 /*这个不用解释了吧？*/ JINTools JNI相关的东西 大部分是静态方法 这个JINTools的名字当时写错了...应该是JNITools...哈哈！ LifeObject 具有生命的对象 MapAnalysis 游戏地图...
GameObject Editor Tool-Unity3d游戏对象编辑工具插件
04-25
GAMEOBJECT EDITOR TOOL Unity3d游戏对象编辑工具插件 “GAMEOBJECT EDITOR TOOL” 功能： - 更改当前所选 GameObject 或 GameObjects 的网格。 - 为任何所选的 GameObjects 分配一个新名称。 - 更改任何所选 ...
G2Dj:使用Java和OpenGL的跨平台游戏引擎
05-10
Java和OpenGLES中的跨平台游戏引擎。 专为2D，低保真图形而设计，但能够为“ 2.5D”项目提供3D透视图渲染。 适用于Mac / Linux / Windows和Android。 游戏是针对实体组件系统进行编程的，游戏所使用的组件取决于一...
Translating-a-Unity-GameObject-Between-Two-Vectors:一个简单的Unity C＃脚本，可以按照给定的间隔连续地来回转换GameObject
05-08
由于我们希望转换的GameObject从屏幕的左侧开始，并且我们希望它从向右移动开始，因此我们在Start()函数中将其设置为true。 这是脚本的主要逻辑，我将在以后逐行解释。 请注意，它要附加到我们正在翻译的对象上。 ...
component、constituent、element、ingredient的区别
热门推荐
图形跟班
01-11 1万+
文章转自：http://www.hbenglish.com/englishangle/detail-1534.aspx 版权归原作者。 component：指一个整体的组成部分。 constituent：常可与component换用，指某一整体不可少的部分或成分。 element：指一个整体必不可少或固有的部分，强调一个复杂整体中最基本、最简单的元件、元素或成分等。 ingredient
【Unity学习笔记】Component、Transform、GameObject、Object四个重要类
weixin_43502713的博客
08-08 4014
调试 1、控制台调试 Debug.Log(变量)；print(变量);//用完一定记得删掉!!! 2、定义共有变量，程序运行后在检测面板查看数据//可观察数据的变化规律啥的 VS调试： **单帧调试：**启动调试–>>运行场景–>>暂停游戏–>>加断点–>>单帧执行–>>结束调试 调试过程中，输入代码：1、右键–快速监视 2、也可以查看“即时窗口” 组件（Component）的认识 1、组件的定义 组件 是在游戏对象（Game Object）中的
控制gameObject随机旋转的功能代码
妙趣又横生
03-21 3321
大纲： 1）添加一个游戏对象 2）控制游戏对象自动随机旋转 3 ) 运行 4）引出的新问题？旋转体旋转越来越慢了？ 实现： 1、在Hierarchy视图新建一个空的游戏对象Asteroid，重置Transform组件。添加Rigidbody组件，取消勾选Use Gravity(取消重力的影响，根据自己项目需要)，添加Capsule Collider组件，勾选Is Trigger选项(为
C++游戏编程教程（四）
[PE]经典八炮的博客
10-05 1647
这篇博客，我们说一下Actor、Component和DrawComponent类的代码。代码都很简单，所以写到了一篇里。 Actor 这个类是角色类，保存了角色的一些基本信息。 代码 Actor.h: #pragma once #include <vector> #include "Math.h" #include<SDL.h> #include"Game.h" class Actor { public: enum State { EActive, EPaused,
该怎么样用C++来实现类Unity3d的AddComponent
Hello Captain
04-11 3557
Unity3d 越来越完善，朝着它学习的人也越来越多。一是因为Unity3d是一整套开发工具，使用起来简单快捷。二是 Mono C#的快速开发上手简单。在Unity编辑器中，添加一个GameObject ， 然后把一个继承自MonoBehavior的脚本拖到GameObject上，即可对GameObject进行操作。或者在代码中new 一个GameObject，然后用AddComponet 挂载一个脚本到GameObject上。
OpenGL图像格式
Frank的专栏
11-22 5655
OpenGL ImageFormat
C++ | Leetcode C++题解之第129题求根节点到叶节点数字之和
Ddddddd_158的博客
06-04 329
C++ | Leetcode C++题解之第129题求根节点到叶节点数字之和
【C++】list的使用（下）
2303_79329831的博客
06-01 1191
本篇博客主要内容：STL库中list用法的讲解。让我们接着上一篇博文的内容继续，进入list最后一个模块，操作list对象的接口函数。本篇文章所讲到的list内容出自于同一个模块，由于其排序和合并的方式涉及到了仿函数的传递，所以内容和篇幅稍微会大一些。相信学完本篇内容之后，能对list的使用和C++有更充分的了解。♥STLC++
C语言从头学17——sizeof 运算符
最新发布
m0_72128260的博客
06-07 120
介绍sizeof，C 语言中的一个运算符，我们也可以理解为是一个函数。
Unity 3D游戏-消消乐（三消类）教程和源码
06-02
很高兴为您提供Unity 3D游戏-消消乐（三消类）教程和源码。 首先，您需要安装Unity 3D引擎，然后创建一个新的项目。接下来，您可以按照以下步骤构建您的游戏： 1. 创建一个3D场景并添加相机和灯光。 2. 创建一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值