CSE::CameraComponent Class Reference

Inheritance diagram for CSE::CameraComponent:

Public Types
enum	CAMERATYPE { PERSPECTIVE = 1 , ORTHO = 2 , CUBE = 3 }
Public Types inherited from CSE::CameraBase
enum	BackgroundType { NONE = 0 , SOLID = 1 , SKYBOX = 2 }

Public Member Functions
	COMPONENT_DEFINE_CONSTRUCTOR (CameraComponent)
void	Exterminate () override
void	Init () override
void	Tick (float elapsedTime) override
SComponent *	Clone (SGameObject *object) override
void	CopyReference (SComponent *src, std::map< SGameObject *, SGameObject * > lists_obj, std::map< SComponent *, SComponent * > lists_comp) override
void	SetValue (std::string name_str, Arguments value) override
std::string	PrintValue () const override
mat4	GetCameraMatrix () const
vec3	GetCameraPosition () const
mat4	GetProjectionMatrix () const
CameraMatrixStruct	GetCameraMatrixStruct () const override
void	SetTargetVector (const vec3 &target)
void	SetTarget (SGameObject *gameObject)
void	SetUp (const vec3 &up)
void	SetCameraType (CAMERATYPE type)
void	SetPerspectiveFov (float fov)
void	SetZDepthRange (float near, float far)
void	SetPerspective (float fov, float near, float far)
void	SetOrtho (float left, float right, float top, float bottom)
void	SetCubeCamera ()
void	SetProjectionMatrix () const
SFrameBuffer *	GetFrameBuffer () const override
void	SetFrameBuffer (SFrameBuffer *frameBuffer)
BackgroundType	GetBackgroundType () override
void	RenderBackground () const override
void	SetBackgroundSkybox (STexture *skyboxTexture=nullptr)
void	SetBackgroundColor (vec3 &&color)
void	SetBackgroundType (BackgroundType type)
Public Member Functions inherited from CSE::SComponent
	SComponent (std::string classType, SGameObject *gameObject)
	SComponent (SGameObject *gameObject)
	SComponent (const SComponent &src)
void	Start () override
virtual auto	GetComponent () -> SObject *
void	SetValue (std::string name_str, Arguments value) override
std::string	PrintValue () const override
void	SetGameObject (SGameObject *object)
virtual SGameObject *	GetGameObject () const
virtual bool	GetIsEnable () const
virtual void	SetIsEnable (bool is_enable)
Public Member Functions inherited from CSE::SObject
	SObject (bool isRegister)
virtual void	SetUndestroyable (bool enable)
virtual void	Destroy ()
std::string	GetHash () const
virtual void	SetHash (std::string &hash)
Public Member Functions inherited from CSE::SISComponent
	SISComponent (const SISComponent &src)=default
Public Member Functions inherited from CSE::VariableBinder
Public Member Functions inherited from CSE::ReflectionObject
	ReflectionObject (std::string type)
void	SetClassType (std::string type)
const char *	GetClassType () const
bool	IsSameClass (const char *classType) const
Public Member Functions inherited from CSE::CameraBase

Additional Inherited Members
Static Public Member Functions inherited from CSE::ReflectionObject
static ReflectionObject *	NewObject (const std::string &name)
Protected Types inherited from CSE::VariableBinder
typedef std::vector< std::string >	Arguments
Protected Member Functions inherited from CSE::VariableBinder
Protected Attributes inherited from CSE::SComponent
SGameObject *	gameObject = nullptr
bool	isEnable = true
Protected Attributes inherited from CSE::SObject
std::string	m_hash
Protected Attributes inherited from CSE::ReflectionObject
std::string	m_class

Detailed Description

Definition at line 31 of file CameraComponent.h.

Member Enumeration Documentation

CAMERATYPE

enum CSE::CameraComponent::CAMERATYPE

Definition at line 33 of file CameraComponent.h.

                        {
            PERSPECTIVE = 1, ORTHO = 2, CUBE = 3
        };

Member Function Documentation

Clone()

SComponent * CameraComponent::Clone ( SGameObject * object )

overridevirtual

Reimplemented from CSE::SComponent.

Definition at line 46 of file CameraComponent.cpp.

                                                      {
    INIT_COMPONENT_CLONE(CameraComponent, comp);
 
    comp->m_eye = m_eye;
    comp->m_target = m_target;
    comp->m_up = m_up;
 
    comp->m_cameraMatrix = m_cameraMatrix;
    comp->m_projectionMatrix = m_projectionMatrix;
    comp->m_resultTarget = m_resultTarget;
    comp->m_frameBuffer = m_frameBuffer;
 
    comp->m_type = m_type;
    comp->m_isProjectionInited = m_isProjectionInited;
 
    //perspective
    comp->m_pFov = m_pFov;
    comp->m_pRatio = m_pRatio;
 
    //Orthographic
    comp->m_oLeft = m_oLeft;
    comp->m_oRight = m_oRight;
    comp->m_oBottom = m_oBottom;
    comp->m_oTop = m_oTop;
 
    comp->m_Near = m_Near;
    comp->m_Far = m_Far;
 
    //Background
    comp->m_backgroundType = m_backgroundType;
    comp->m_backgroundColor = m_backgroundColor;
    if(comp->m_backgroundMap == nullptr) comp->m_backgroundMap = new BackgroundMapStruct();
    comp->m_backgroundMap->map = m_backgroundMap->map;
    comp->m_backgroundMap->mapId = m_backgroundMap->mapId;
    comp->m_backgroundMap->viewId = m_backgroundMap->viewId;
    comp->m_backgroundMap->projectionId = m_backgroundMap->projectionId;
 
    return comp;
}

CopyReference()

void CameraComponent::CopyReference ( SComponent * src, std::map< SGameObject *, SGameObject * > lists_obj, std::map< SComponent *, SComponent * > lists_comp )

overridevirtual

Reimplemented from CSE::SComponent.

Definition at line 86 of file CameraComponent.cpp.

                                                                                 {
    if (src == nullptr) return;
    auto convert = static_cast<CameraComponent*>(src);
 
    //Copy GameObjects
    FIND_OBJ_REFERENCE(m_targetObject, convert);
 
}

Exterminate()

void CameraComponent::Exterminate ( )

overridevirtual

Implements CSE::SObject.

Definition at line 22 of file CameraComponent.cpp.

                                  {
    SAFE_DELETE(m_backgroundMap);
    CORE->GetCore(CameraMgr)->Remove(this);
}

GetBackgroundType()

CameraBase::BackgroundType CameraComponent::GetBackgroundType ( )

overridevirtual

Reimplemented from CSE::CameraBase.

Definition at line 246 of file CameraComponent.cpp.

                                                            {
    return m_backgroundType;
}

GetCameraMatrix()

mat4 CameraComponent::GetCameraMatrix

(

)

const

Definition at line 146 of file CameraComponent.cpp.

                                            {
    return m_cameraMatrix;
}

GetCameraMatrixStruct()

CameraMatrixStruct CameraComponent::GetCameraMatrixStruct ( ) const

overridevirtual

Implements CSE::CameraBase.

Definition at line 234 of file CameraComponent.cpp.

                                                                {
    return { m_cameraMatrix, GetProjectionMatrix(), GetCameraPosition() };
}

GetCameraPosition()

vec3 CameraComponent::GetCameraPosition

(

)

const

Definition at line 150 of file CameraComponent.cpp.

                                              {
    mat4 matrix = static_cast<TransformComponent*>(gameObject->GetTransform())->GetMatrix();
    return vec3{ matrix.w.x, matrix.w.y, matrix.w.z };
}

GetFrameBuffer()

SFrameBuffer * CameraComponent::GetFrameBuffer ( ) const

overridevirtual

Implements CSE::CameraBase.

Definition at line 238 of file CameraComponent.cpp.

                                                    {
    return m_frameBuffer;
}

GetProjectionMatrix()

mat4 CSE::CameraComponent::GetProjectionMatrix ( ) const

inline

Definition at line 60 of file CameraComponent.h.

                                         {
            if (!m_isProjectionInited) {
                SetProjectionMatrix();
            }
            return m_projectionMatrix;
        }

Init()

void CameraComponent::Init ( )

overridevirtual

Implements CSE::SISComponent.

Definition at line 27 of file CameraComponent.cpp.

                           {
    m_eye = static_cast<TransformComponent*>(gameObject->GetTransform())->GetPosition();
 
    m_resultTarget = vec3();
    m_pRatio = const_cast<float*>(CORE->GetCore(CameraMgr)->GetProjectionRatio());
    Tick(0);
}

PrintValue()

std::string CameraComponent::PrintValue ( ) const

overridevirtual

Implements CSE::VariableBinder.

Definition at line 212 of file CameraComponent.cpp.

                                            {
    PRINT_START("component");
 
    PRINT_VALUE_VEC3(m_target);
    PRINT_VALUE_VEC3(m_up);
    PRINT_VALUE("obj", m_targetObject, m_targetObject == nullptr ? "" : ConvertSpaceStr(m_targetObject->GetHash()));
    PRINT_VALUE_MAT4(m_cameraMatrix);
    PRINT_VALUE_MAT4(m_projectionMatrix);
    PRINT_VALUE("int", m_type, static_cast<int>(m_type));
    PRINT_VALUE("float", m_pFov, m_pFov);
    PRINT_VALUE("vec4", m_orthoValue, m_oLeft, ' ', m_oRight, ' ', m_oBottom, ' ', m_oTop);
    PRINT_VALUE("vec2", m_distance, m_Near, ' ', m_Far);
    if (m_frameBuffer != nullptr) PRINT_RES_NAME(m_frameBuffer, m_frameBuffer);
 
    PRINT_VALUE("int", m_backgroundType, static_cast<int>(m_backgroundType));
    PRINT_VALUE_COLOR3(m_backgroundColor);
    if (m_backgroundMap != nullptr && m_backgroundMap->map != nullptr)
        PRINT_RES_NAME(m_backgroundMap.map, m_backgroundMap->map);
 
    PRINT_END("component");
}

RenderBackground()

void CameraComponent::RenderBackground ( ) const

overridevirtual

Implements CSE::CameraBase.

Definition at line 250 of file CameraComponent.cpp.

                                             {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    switch (m_backgroundType) {
        case SOLID:
            glClearColor(m_backgroundColor.x, m_backgroundColor.y, m_backgroundColor.z, 1.0f);
            glClear(GL_COLOR_BUFFER_BIT);
            break;
        case SKYBOX:
            const auto& mapStruct = m_backgroundMap;
            if (mapStruct->map == nullptr) return;
 
            glUseProgram(m_globalSkyboxHandle->Program);
            m_globalSkyboxHandle->SetUniformMat4("PROJECTION_MATRIX", m_projectionMatrix);
            auto viewMatrix = mat4(m_cameraMatrix.ToMat3());
            m_globalSkyboxHandle->SetUniformMat4("VIEW_MATRIX", viewMatrix);
            mapStruct->map->Bind(mapStruct->mapId, 0);
 
            glDisable(GL_CULL_FACE);
            glDisable(GL_DEPTH_TEST);
            ShaderUtil::BindAttributeToCubeMap();
            glEnable(GL_DEPTH_TEST);
            glEnable(GL_CULL_FACE);
            break;
    }
}

SetBackgroundColor()

void CameraComponent::SetBackgroundColor

(

vec3 &&

color

)

Definition at line 290 of file CameraComponent.cpp.

                                                     {
    m_backgroundColor = color;
}

SetBackgroundSkybox()

void CameraComponent::SetBackgroundSkybox

(

STexture *

skyboxTexture = nullptr

)

Definition at line 277 of file CameraComponent.cpp.

                                                                 {
    if (skyboxTexture == nullptr) {
        skyboxTexture = SResource::Get<STexture>("envCubemap.textureCubeMap");
    }
    if (m_backgroundMap == nullptr) m_backgroundMap = new BackgroundMapStruct();
 
    m_backgroundMap->map = skyboxTexture;
    m_backgroundMap->mapId = static_cast<unsigned short>(m_globalSkyboxHandle->UniformLocation("ENV_MAP")->id);
    m_backgroundMap->viewId = static_cast<unsigned short>(m_globalSkyboxHandle->UniformLocation("VIEW_MATRIX")->id);
    m_backgroundMap->projectionId = static_cast<unsigned short>(m_globalSkyboxHandle->UniformLocation(
            "PROJECTION_MATRIX")->id);
}

SetBackgroundType()

void CameraComponent::SetBackgroundType

(

CameraBase::BackgroundType

type

)

Definition at line 294 of file CameraComponent.cpp.

                                                                     {
    m_backgroundType = type;
}

SetCameraType()

void CameraComponent::SetCameraType

(

CAMERATYPE

type

)

Definition at line 108 of file CameraComponent.cpp.

                                                   {
    m_type = type;
}

SetCubeCamera()

void CameraComponent::SetCubeCamera

(

)

Definition at line 138 of file CameraComponent.cpp.

                                    {
    m_type = CUBE;
}

SetFrameBuffer()

void CameraComponent::SetFrameBuffer

(

SFrameBuffer *

frameBuffer

)

Definition at line 242 of file CameraComponent.cpp.

                                                              {
    m_frameBuffer = frameBuffer;
}

SetOrtho()

void CameraComponent::SetOrtho	(	float	left,
		float	right,
		float	top,
		float	bottom )

Definition at line 130 of file CameraComponent.cpp.

                                                                               {
    m_type = ORTHO;
    m_oLeft = left;
    m_oRight = right;
    m_oBottom = bottom;
    m_oTop = top;
}

SetPerspective()

void CameraComponent::SetPerspective	(	float	fov,
		float	near,
		float	far )

Definition at line 122 of file CameraComponent.cpp.

                                                                     {
    m_type = PERSPECTIVE;
    m_pFov = fov;
    m_Near = near;
    m_Far = far;
 
}

SetPerspectiveFov()

void CameraComponent::SetPerspectiveFov

(

float

fov

)

Definition at line 112 of file CameraComponent.cpp.

                                                 {
    m_pFov = fov;
}

SetProjectionMatrix()

void CameraComponent::SetProjectionMatrix

(

)

const

Definition at line 155 of file CameraComponent.cpp.

                                                {
        std::mutex mutex;
        mutex.lock();
 
    switch (m_type) {
        case PERSPECTIVE:
            m_projectionMatrix = mat4::Perspective(m_pFov, *m_pRatio, m_Near, m_Far);
            break;
        case ORTHO:
            m_projectionMatrix = mat4::Ortho(m_oLeft, m_oRight, m_oTop, m_oBottom, m_Near, m_Far);
            break;
        case CUBE:
            m_projectionMatrix = mat4::Perspective(90.0f, 1.0f, 0.1f, 10.0f);
            break;
    }
 
    m_isProjectionInited = true;
        mutex.unlock();
}

SetTarget()

void CameraComponent::SetTarget

(

SGameObject *

gameObject

)

Definition at line 100 of file CameraComponent.cpp.

                                                       {
    m_targetObject = gameObject;
}

SetTargetVector()

void CameraComponent::SetTargetVector

(

const vec3 &

target

)

Definition at line 96 of file CameraComponent.cpp.

                                                        {
    m_target = target;
}

SetUp()

void CameraComponent::SetUp

(

const vec3 &

up

)

Definition at line 104 of file CameraComponent.cpp.

                                          {
    m_up = up;
}

SetValue()

void CameraComponent::SetValue ( std::string name_str, Arguments value )

overridevirtual

Used to get serialized values. All classes that inherit from VariableBinder will unconditionally call this function first during initialization.

Parameters

name_str	Name of values
value	Serialized values

Implements CSE::VariableBinder.

Definition at line 175 of file CameraComponent.cpp.

                                                                                {
    if (name_str == "m_target") {
        SET_VEC3(m_target);
    } else if (name_str == "m_up") {
        SET_VEC3(m_up);
    } else if (name_str == "m_targetObject") {
        if(value.size() <= 0) return;
        m_targetObject = SGameObject::FindByHash(value[0]);
    } else if (name_str == "m_cameraMatrix") {
        SET_MAT4(m_cameraMatrix);
    } else if (name_str == "m_projectionMatrix") {
        SET_MAT4(m_projectionMatrix);
    } else if (name_str == "m_type") {
        m_type = static_cast<CAMERATYPE>(std::stoi(value[0]));
    } else if (name_str == "m_pFov") {
        m_pFov = std::stof(value[0]);
    } else if (name_str == "m_orthoValue") {
        m_oLeft = std::stof(value[0]);
        m_oRight = std::stof(value[1]);
        m_oBottom = std::stof(value[2]);
        m_oTop = std::stof(value[3]);
 
    } else if (name_str == "m_distance") {
        m_Near = std::stof(value[0]);
        m_Far = std::stof(value[1]);
    } else if (name_str == "m_frameBuffer") {
        m_frameBuffer = SResource::Create<SFrameBuffer>(value[0]);
    } else if (name_str == "m_backgroundType") {
        m_backgroundType = static_cast<BackgroundType>(std::stoi(value[0]));
    } else if (name_str == "m_backgroundColor") {
        SET_VEC3(m_backgroundColor);
    } else if (name_str == "m_backgroundMap.map") {
        SetBackgroundSkybox(SResource::Create<STexture>(value[0]));
    }
 
}

SetZDepthRange()

void CameraComponent::SetZDepthRange	(	float	near,
		float	far )

Definition at line 116 of file CameraComponent.cpp.

                                                          {
    m_Near = near;
    m_Far = far;
 
}

Tick()

void CameraComponent::Tick ( float elapsedTime )

overridevirtual

Implements CSE::SISComponent.

Definition at line 35 of file CameraComponent.cpp.

                                            {
    if(m_type == CUBE) return;
 
    if (m_targetObject == nullptr)
        m_resultTarget = *m_eye + m_target;
    else {
        m_resultTarget = *static_cast<TransformComponent*>(m_targetObject->GetTransform())->GetPosition();
    }
    SetCameraMatrix();
}

---

The documentation for this class was generated from the following files:

• Component/CameraComponent.h
• Component/CameraComponent.cpp