281 lines
7.4 KiB
C++
281 lines
7.4 KiB
C++
#include "StdAfx.h"
|
|
#include "CRenderTarget.h"
|
|
#include "../EterLib/Camera.h"
|
|
#include "../EterLib/CRenderTargetManager.h"
|
|
#include "../EterPythonLib/PythonGraphic.h"
|
|
|
|
#include "../EterBase/Timer.h"
|
|
#include "../EterBase/CRC32.h"
|
|
|
|
#include "../GameLib/GameType.h"
|
|
#include "../GameLib/MapType.h"
|
|
#include "../GameLib/ItemData.h"
|
|
#include "../GameLib/ItemManager.h"
|
|
#include "../GameLib/ActorInstance.h"
|
|
#include "../UserInterface/InstanceBase.h"
|
|
//#include "../UserInterface/PythonNonPlayer.h"
|
|
#include "ResourceManager.h"
|
|
|
|
CRenderTarget::~CRenderTarget() {}
|
|
|
|
CRenderTarget::CRenderTarget(const DWORD width, const DWORD height) :
|
|
m_pModel(nullptr),
|
|
m_background(nullptr),
|
|
m_modelRotation(0),
|
|
m_visible(false),
|
|
m_pmodelRotationActive(true),
|
|
m_v3Eye(0.0f, 0.0f, 0.0f),
|
|
m_v3Target(0.0f, 0.0f, 0.0f),
|
|
m_v3Up(0.0f, 0.0f, 1.0f),
|
|
m_v3AngularVelocity(0.0f, 0.0f, 0.0f),
|
|
m_bScale(1.0),
|
|
m_bShowModel(true)
|
|
{
|
|
//auto pTex = new CGraphicRenderTargetTexture;
|
|
auto pTex = std::make_unique<CGraphicRenderTargetTexture>();
|
|
if (!pTex->Create(width, height, D3DFMT_X8R8G8B8, D3DFMT_D16))
|
|
{
|
|
//delete pTex;
|
|
TraceError("CRenderTarget::CRenderTarget: Could not create CGraphicRenderTargetTexture %dx%d", width, height);
|
|
throw std::runtime_error("CRenderTarget::CRenderTarget: Could not create CGraphicRenderTargetTexture");
|
|
}
|
|
|
|
m_renderTargetTexture = std::move(pTex);
|
|
}
|
|
|
|
void CRenderTarget::RenderTexture() const
|
|
{
|
|
m_renderTargetTexture->Render();
|
|
}
|
|
|
|
void CRenderTarget::SetRenderingRect(RECT* rect) const
|
|
{
|
|
m_renderTargetTexture->SetRenderingRect(rect);
|
|
}
|
|
|
|
void CRenderTarget::CreateTextures() const
|
|
{
|
|
m_renderTargetTexture->CreateTextures();
|
|
}
|
|
|
|
void CRenderTarget::ReleaseTextures() const
|
|
{
|
|
m_renderTargetTexture->ReleaseTextures();
|
|
}
|
|
|
|
void CRenderTarget::ResetModel()
|
|
{
|
|
if (m_pModel)
|
|
{
|
|
m_pModel->ClearWikiAffect();
|
|
m_pModel.reset();
|
|
}
|
|
}
|
|
|
|
void CRenderTarget::SetScale(float fScale)
|
|
{
|
|
m_bScale = fScale;
|
|
if (IsReady())
|
|
SelectModel(m_pModel->GetRace(), true);
|
|
}
|
|
void CRenderTarget::SelectModel(const int index, bool isFromScale)
|
|
{
|
|
if (m_pModel && !isFromScale && m_pModel->GetRace() == index)
|
|
return;
|
|
|
|
if (isFromScale && m_pModel)
|
|
m_pModel.reset();
|
|
|
|
CInstanceBase::SCreateData kCreateData{};
|
|
kCreateData.m_bType = CActorInstance::TYPE_NPC;
|
|
kCreateData.m_dwRace = index;
|
|
auto model = std::make_unique<CInstanceBase>();
|
|
if (!model->Create(kCreateData))
|
|
{
|
|
ResetModel();
|
|
return;
|
|
}
|
|
m_pModel = std::move(model);
|
|
m_pModel->NEW_SetPixelPosition(TPixelPosition(0, 0, 0));
|
|
m_pModel->SetAlwaysRender(true);
|
|
m_pModel->SetRotation(0.0f);
|
|
|
|
float fTargetHeight = 110.0f;
|
|
|
|
m_v3Eye.x = 0.0f;
|
|
m_v3Eye.y = -1000.0f;
|
|
m_v3Eye.z = 600.0f;
|
|
|
|
m_v3Target.x = 0.0f;
|
|
m_v3Target.y = 0.0f;
|
|
m_v3Target.z = 95.0f;
|
|
|
|
if (index > (NRaceData::JOB_MAX_NUM * 2))
|
|
{
|
|
const auto ptrGraphicInstance = m_pModel->GetGraphicThingInstancePtr();
|
|
if (ptrGraphicInstance) {
|
|
const float fRaceHeight = (ptrGraphicInstance->GetHeight()/m_bScale);
|
|
fTargetHeight = fRaceHeight / 2.0f;
|
|
m_v3Eye.y = -(fRaceHeight * 8.9f);
|
|
m_v3Eye.z = 0.0f;
|
|
m_v3Target.z = fRaceHeight / 2.0f;
|
|
}
|
|
}
|
|
|
|
auto& camera_manager = CCameraManager::instance();
|
|
camera_manager.SetCurrentCamera(CCameraManager::DEFAULT_ORTHO_CAMERA);
|
|
camera_manager.GetCurrentCamera()->SetTargetHeight(fTargetHeight);
|
|
camera_manager.ResetToPreviousCamera();
|
|
m_modelRotation = 0.0f;
|
|
}
|
|
|
|
bool CRenderTarget::CreateBackground(const char* imgPath, const DWORD width, const DWORD height)
|
|
{
|
|
if (m_background)
|
|
return false;
|
|
|
|
m_background = std::make_unique<CGraphicImageInstance>();
|
|
|
|
const auto graphic_image = dynamic_cast<CGraphicImage*>(CResourceManager::instance().GetResourcePointer(imgPath));
|
|
if (!graphic_image)
|
|
{
|
|
m_background.reset();
|
|
return false;
|
|
}
|
|
|
|
m_background->SetImagePointer(graphic_image);
|
|
m_background->SetScale(static_cast<float>(width) / graphic_image->GetWidth(), static_cast<float>(height) / graphic_image->GetHeight());
|
|
return true;
|
|
}
|
|
|
|
void CRenderTarget::RenderBackground() const
|
|
{
|
|
if (!m_background)
|
|
return;
|
|
|
|
auto& rectRender = *m_renderTargetTexture->GetRenderingRect();
|
|
m_renderTargetTexture->SetRenderTarget();
|
|
|
|
CGraphicRenderTargetTexture::Clear();
|
|
CPythonGraphic::Instance().SetInterfaceRenderState();
|
|
|
|
const auto width = static_cast<float>(rectRender.right - rectRender.left);
|
|
const auto height = static_cast<float>(rectRender.bottom - rectRender.top);
|
|
|
|
CPythonGraphic::Instance().SetViewport(0.0f, 0.0f, width, height);
|
|
|
|
m_background->Render();
|
|
m_renderTargetTexture->ResetRenderTarget();
|
|
}
|
|
|
|
void CRenderTarget::UpdateModel()
|
|
{
|
|
if (!IsReady())
|
|
return;
|
|
|
|
if (m_pmodelRotationActive && m_bShowModel)
|
|
{
|
|
if (m_modelRotation < 360.0f)
|
|
m_modelRotation += 1.0f / 60 * 60.0f;
|
|
else
|
|
m_modelRotation = 0.0f / 60 * 60.0f;
|
|
|
|
m_pModel->SetRotation(m_modelRotation);
|
|
}
|
|
else
|
|
m_pModel->SetRotation(0.0f);
|
|
m_pModel->Transform();
|
|
if(m_pmodelRotationActive)
|
|
m_pModel->GetGraphicThingInstanceRef().RotationProcess();
|
|
}
|
|
|
|
void CRenderTarget::DeformModel()
|
|
{
|
|
if (!IsReady())
|
|
return;
|
|
m_pModel->Deform();
|
|
}
|
|
|
|
void CRenderTarget::RenderModel()
|
|
{
|
|
if (!IsReady())
|
|
return;
|
|
|
|
auto& python_graphic = CPythonGraphic::Instance();
|
|
auto& camera_manager = CCameraManager::instance();
|
|
auto& state_manager = CStateManager::Instance();
|
|
auto& rectRender = *m_renderTargetTexture->GetRenderingRect();
|
|
|
|
|
|
m_renderTargetTexture->SetRenderTarget();
|
|
if (!m_background)
|
|
m_renderTargetTexture->Clear();
|
|
|
|
python_graphic.ClearDepthBuffer();
|
|
|
|
const auto fov = python_graphic.GetFOV();
|
|
const auto aspect = python_graphic.GetAspect();
|
|
const auto near_y = python_graphic.GetNear();
|
|
const auto far_y = python_graphic.GetFar();
|
|
|
|
const auto width = static_cast<float>(rectRender.right - rectRender.left);
|
|
const auto height = static_cast<float>(rectRender.bottom - rectRender.top);
|
|
|
|
state_manager.SetRenderState(D3DRS_FOGENABLE, FALSE);
|
|
|
|
python_graphic.SetViewport(0.0f, 0.0f, width, height);
|
|
python_graphic.PushState();
|
|
|
|
camera_manager.SetCurrentCamera(CCameraManager::DEFAULT_ORTHO_CAMERA);
|
|
camera_manager.GetCurrentCamera()->SetViewParams(m_v3Eye, m_v3Target, m_v3Up);
|
|
camera_manager.GetCurrentCamera()->RotateEyeAroundTarget(m_v3AngularVelocity.z, m_v3AngularVelocity.x);
|
|
|
|
python_graphic.UpdateViewMatrix();
|
|
python_graphic.SetPerspective(10.0f, width / height, 100.0f, 15000.0f);
|
|
|
|
if (m_bShowModel)
|
|
{
|
|
m_pModel->Update();
|
|
m_pModel->Render();
|
|
}
|
|
m_pModel->GetGraphicThingInstancePtr()->RenderAllAttachingEffectWiki();
|
|
|
|
camera_manager.ResetToPreviousCamera();
|
|
python_graphic.RestoreViewport();
|
|
python_graphic.PopState();
|
|
python_graphic.SetPerspective(fov, aspect, near_y, far_y);
|
|
|
|
m_renderTargetTexture->ResetRenderTarget();
|
|
|
|
state_manager.SetRenderState(D3DRS_FOGENABLE, TRUE);
|
|
}
|
|
|
|
void CRenderTarget::SetModelV3Eye(float x, float y, float z)
|
|
{
|
|
m_v3Eye.x = x;
|
|
m_v3Eye.y = y;
|
|
m_v3Eye.z = z;
|
|
}
|
|
|
|
void CRenderTarget::SetModelV3Target(float x, float y, float z)
|
|
{
|
|
m_v3Target.x = x;
|
|
m_v3Target.y = y;
|
|
m_v3Target.z = z;
|
|
}
|
|
|
|
void CRenderTarget::RotateEyeAroundTarget(float fPitchDegree, float fRollDegree)
|
|
{
|
|
m_v3AngularVelocity.x = fRollDegree;
|
|
m_v3AngularVelocity.z = fPitchDegree;
|
|
}
|
|
|
|
void CRenderTarget::Zoom(float fRatio)
|
|
{
|
|
if (fRatio == 1.0f)
|
|
return;
|
|
D3DXVECTOR3 v3Temp = m_v3Eye - m_v3Target;
|
|
v3Temp *= fRatio;
|
|
m_v3Eye = v3Temp + m_v3Target;
|
|
}
|