2016-03-04 23:04:53 +00:00
|
|
|
#include "Graphics/CModel.hpp"
|
2016-03-30 20:44:19 +00:00
|
|
|
#include "Graphics/CTexture.hpp"
|
2016-03-30 19:16:01 +00:00
|
|
|
#include "Graphics/CGraphics.hpp"
|
2016-04-04 02:32:57 +00:00
|
|
|
#include "Graphics/CLight.hpp"
|
2016-03-30 19:16:01 +00:00
|
|
|
#include "hecl/HMDLMeta.hpp"
|
2016-03-31 02:44:43 +00:00
|
|
|
#include "hecl/Runtime.hpp"
|
2016-04-04 06:16:03 +00:00
|
|
|
#include "boo/graphicsdev/Metal.hpp"
|
2016-07-21 05:21:45 +00:00
|
|
|
#include "Shaders/CModelShaders.hpp"
|
2016-07-31 02:06:47 +00:00
|
|
|
#include "Graphics/CBooRenderer.hpp"
|
2016-08-21 20:39:18 +00:00
|
|
|
#include "Character/CSkinRules.hpp"
|
2016-07-31 02:06:47 +00:00
|
|
|
#include "GameGlobalObjects.hpp"
|
2016-07-31 20:52:04 +00:00
|
|
|
#include <array>
|
2016-02-13 00:57:09 +00:00
|
|
|
|
2016-03-04 23:04:53 +00:00
|
|
|
namespace urde
|
2016-02-13 00:57:09 +00:00
|
|
|
{
|
2016-09-02 17:50:03 +00:00
|
|
|
static logvisor::Module Log("urde::CBooModel");
|
2016-03-30 19:16:01 +00:00
|
|
|
bool CBooModel::g_DrawingOccluders = false;
|
2016-03-29 23:14:14 +00:00
|
|
|
|
2016-09-02 19:32:57 +00:00
|
|
|
CBooModel::CBooModel(TToken<CModel>& token, std::vector<CBooSurface>* surfaces, SShader& shader,
|
2016-03-31 02:44:43 +00:00
|
|
|
boo::IVertexFormat* vtxFmt, boo::IGraphicsBufferS* vbo, boo::IGraphicsBufferS* ibo,
|
2016-04-05 01:51:25 +00:00
|
|
|
size_t weightVecCount, size_t skinBankCount, const zeus::CAABox& aabb)
|
2016-09-02 19:32:57 +00:00
|
|
|
: m_model(token), x0_surfaces(surfaces), x4_matSet(&shader.m_matSet), m_matSetIdx(shader.m_matSetIdx),
|
|
|
|
m_pipelines(&shader.m_shaders), m_vtxFmt(vtxFmt), x8_vbo(vbo), xc_ibo(ibo), m_weightVecCount(weightVecCount),
|
|
|
|
m_skinBankCount(skinBankCount), x1c_textures(shader.x0_textures), x20_aabb(aabb),
|
|
|
|
x40_24_texturesLoaded(false), x40_25_modelVisible(0)
|
2016-03-31 02:44:43 +00:00
|
|
|
{
|
|
|
|
for (CBooSurface& surf : *x0_surfaces)
|
2016-03-29 23:14:14 +00:00
|
|
|
surf.m_parent = this;
|
|
|
|
|
|
|
|
for (auto it=x0_surfaces->rbegin() ; it != x0_surfaces->rend() ; ++it)
|
|
|
|
{
|
2016-03-31 02:44:43 +00:00
|
|
|
u32 matId = it->m_data.matIdx;
|
2016-03-31 06:18:56 +00:00
|
|
|
const MaterialSet::Material& matData = GetMaterialByIndex(matId);
|
2016-03-31 02:44:43 +00:00
|
|
|
if (matData.flags.depthSorting())
|
2016-03-29 23:14:14 +00:00
|
|
|
{
|
|
|
|
it->m_next = x3c_firstSortedSurface;
|
|
|
|
x3c_firstSortedSurface = &*it;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
it->m_next = x38_firstUnsortedSurface;
|
|
|
|
x38_firstUnsortedSurface = &*it;
|
|
|
|
}
|
|
|
|
}
|
2016-03-31 02:44:43 +00:00
|
|
|
|
|
|
|
if (x40_24_texturesLoaded)
|
|
|
|
BuildGfxToken();
|
2016-03-29 23:14:14 +00:00
|
|
|
}
|
|
|
|
|
2016-03-31 02:44:43 +00:00
|
|
|
void CBooModel::BuildGfxToken()
|
2016-03-29 23:14:14 +00:00
|
|
|
{
|
2016-03-31 06:18:56 +00:00
|
|
|
m_gfxToken = CGraphics::CommitResources(
|
2016-07-08 03:23:58 +00:00
|
|
|
[&](boo::IGraphicsDataFactory::Context& ctx) -> bool
|
2016-03-29 23:14:14 +00:00
|
|
|
{
|
2016-04-04 02:32:57 +00:00
|
|
|
/* Determine space required by uniform buffer */
|
|
|
|
std::vector<size_t> skinOffs;
|
|
|
|
std::vector<size_t> skinSizes;
|
|
|
|
skinOffs.reserve(std::max(size_t(1), m_skinBankCount));
|
|
|
|
skinSizes.reserve(std::max(size_t(1), m_skinBankCount));
|
|
|
|
|
|
|
|
std::vector<size_t> uvOffs;
|
|
|
|
std::vector<size_t> uvSizes;
|
|
|
|
uvOffs.reserve(x4_matSet->materials.size());
|
|
|
|
uvSizes.reserve(x4_matSet->materials.size());
|
|
|
|
|
|
|
|
/* Vert transform matrices */
|
|
|
|
size_t uniBufSize = 0;
|
|
|
|
if (m_skinBankCount)
|
|
|
|
{
|
|
|
|
/* Skinned */
|
|
|
|
for (size_t i=0 ; i<m_skinBankCount ; ++i)
|
|
|
|
{
|
|
|
|
size_t thisSz = ROUND_UP_256(sizeof(zeus::CMatrix4f) * (2 * m_weightVecCount * 4 + 1));
|
|
|
|
skinOffs.push_back(uniBufSize);
|
|
|
|
skinSizes.push_back(thisSz);
|
|
|
|
uniBufSize += thisSz;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Non-Skinned */
|
|
|
|
size_t thisSz = ROUND_UP_256(sizeof(zeus::CMatrix4f) * 3);
|
|
|
|
skinOffs.push_back(uniBufSize);
|
|
|
|
skinSizes.push_back(thisSz);
|
|
|
|
uniBufSize += thisSz;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Animated UV transform matrices */
|
|
|
|
for (const MaterialSet::Material& mat : x4_matSet->materials)
|
|
|
|
{
|
2016-07-31 02:06:47 +00:00
|
|
|
size_t thisSz = ROUND_UP_256(/*mat.uvAnims.size()*/ 8 * (sizeof(zeus::CMatrix4f) * 2));
|
2016-04-04 02:32:57 +00:00
|
|
|
uvOffs.push_back(uniBufSize);
|
|
|
|
uvSizes.push_back(thisSz);
|
|
|
|
uniBufSize += thisSz;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Lighting uniform */
|
|
|
|
size_t lightOff = 0;
|
|
|
|
size_t lightSz = 0;
|
|
|
|
{
|
|
|
|
size_t thisSz = ROUND_UP_256(sizeof(CModelShaders::LightingUniform));
|
|
|
|
lightOff = uniBufSize;
|
|
|
|
lightSz = thisSz;
|
|
|
|
uniBufSize += thisSz;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate resident buffer */
|
|
|
|
m_uniformDataSize = uniBufSize;
|
|
|
|
m_uniformBuffer = ctx.newDynamicBuffer(boo::BufferUse::Uniform, uniBufSize, 1);
|
|
|
|
|
2016-04-04 05:02:09 +00:00
|
|
|
boo::IGraphicsBuffer* bufs[] = {m_uniformBuffer, m_uniformBuffer, m_uniformBuffer};
|
2016-04-04 02:32:57 +00:00
|
|
|
|
|
|
|
/* Binding for each surface */
|
2016-03-31 07:50:52 +00:00
|
|
|
m_shaderDataBindings.clear();
|
2016-04-04 02:32:57 +00:00
|
|
|
m_shaderDataBindings.reserve(x0_surfaces->size());
|
|
|
|
|
2016-03-31 02:44:43 +00:00
|
|
|
std::vector<boo::ITexture*> texs;
|
2016-04-04 05:02:09 +00:00
|
|
|
size_t thisOffs[3];
|
|
|
|
size_t thisSizes[3];
|
2016-04-04 02:32:57 +00:00
|
|
|
|
2016-04-04 06:16:03 +00:00
|
|
|
static const boo::PipelineStage stages[3] = {boo::PipelineStage::Vertex,
|
|
|
|
boo::PipelineStage::Vertex,
|
|
|
|
boo::PipelineStage::Fragment};
|
|
|
|
|
2016-04-04 02:32:57 +00:00
|
|
|
/* Enumerate surfaces and build data bindings */
|
|
|
|
for (const CBooSurface& surf : *x0_surfaces)
|
2016-03-31 02:44:43 +00:00
|
|
|
{
|
2016-04-04 02:32:57 +00:00
|
|
|
const MaterialSet::Material& mat = x4_matSet->materials.at(surf.m_data.matIdx);
|
|
|
|
|
2016-03-31 02:44:43 +00:00
|
|
|
texs.clear();
|
2016-07-31 02:06:47 +00:00
|
|
|
texs.reserve(8);
|
2016-03-31 02:44:43 +00:00
|
|
|
for (atUint32 idx : mat.textureIdxs)
|
|
|
|
{
|
2016-09-02 19:32:57 +00:00
|
|
|
TCachedToken<CTexture>& tex = x1c_textures[idx];
|
2016-03-31 02:44:43 +00:00
|
|
|
texs.push_back(tex.GetObj()->GetBooTexture());
|
|
|
|
}
|
2016-07-31 02:06:47 +00:00
|
|
|
texs.resize(8);
|
|
|
|
texs[7] = g_Renderer->x220_sphereRamp;
|
2016-04-04 02:32:57 +00:00
|
|
|
|
|
|
|
if (m_skinBankCount)
|
|
|
|
{
|
2016-04-04 05:02:09 +00:00
|
|
|
thisOffs[0] = skinOffs[surf.m_data.skinMtxBankIdx];
|
|
|
|
thisSizes[0] = skinSizes[surf.m_data.skinMtxBankIdx];
|
2016-04-04 02:32:57 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-04-04 05:02:09 +00:00
|
|
|
thisOffs[0] = 0;
|
|
|
|
thisSizes[0] = 256;
|
2016-04-04 02:32:57 +00:00
|
|
|
}
|
|
|
|
|
2016-07-31 02:06:47 +00:00
|
|
|
thisOffs[1] = uvOffs[surf.m_data.matIdx];
|
|
|
|
thisSizes[1] = uvSizes[surf.m_data.matIdx];
|
2016-04-04 02:32:57 +00:00
|
|
|
|
2016-04-04 05:02:09 +00:00
|
|
|
thisOffs[2] = lightOff;
|
|
|
|
thisSizes[2] = lightSz;
|
2016-04-04 02:32:57 +00:00
|
|
|
|
|
|
|
const std::vector<boo::IShaderPipeline*>& pipelines = m_pipelines->at(surf.m_data.matIdx);
|
|
|
|
|
|
|
|
m_shaderDataBindings.emplace_back();
|
|
|
|
std::vector<boo::IShaderDataBinding*>& extendeds = m_shaderDataBindings.back();
|
|
|
|
extendeds.reserve(pipelines.size());
|
|
|
|
|
2016-07-31 02:06:47 +00:00
|
|
|
int idx = 0;
|
2016-04-04 02:32:57 +00:00
|
|
|
for (boo::IShaderPipeline* pipeline : pipelines)
|
2016-07-31 02:06:47 +00:00
|
|
|
{
|
2016-04-04 02:32:57 +00:00
|
|
|
extendeds.push_back(
|
2016-07-08 03:23:58 +00:00
|
|
|
ctx.newShaderDataBinding(pipeline, m_vtxFmt,
|
|
|
|
x8_vbo, nullptr, xc_ibo, 3, bufs, stages,
|
2016-07-31 02:06:47 +00:00
|
|
|
thisOffs, thisSizes, (idx == 2) ? 8 : mat.textureIdxs.size(),
|
|
|
|
texs.data()));
|
|
|
|
++idx;
|
|
|
|
}
|
2016-03-31 02:44:43 +00:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2016-03-31 06:18:56 +00:00
|
|
|
void CBooModel::MakeTexuresFromMats(const MaterialSet& matSet,
|
2016-03-31 02:44:43 +00:00
|
|
|
std::vector<TCachedToken<CTexture>>& toksOut,
|
|
|
|
IObjectStore& store)
|
|
|
|
{
|
|
|
|
toksOut.reserve(matSet.head.textureIDs.size());
|
|
|
|
for (const DataSpec::UniqueID32& id : matSet.head.textureIDs)
|
|
|
|
toksOut.emplace_back(store.GetObj({SBIG('TXTR'), id.toUint32()}));
|
|
|
|
}
|
|
|
|
|
2016-04-04 02:32:57 +00:00
|
|
|
void CBooModel::ActivateLights(const std::vector<CLight>& lights)
|
|
|
|
{
|
2016-04-04 05:02:09 +00:00
|
|
|
m_lightingData.ambient = zeus::CColor::skBlack;
|
2016-04-04 02:32:57 +00:00
|
|
|
size_t curLight = 0;
|
|
|
|
|
|
|
|
for (const CLight& light : lights)
|
|
|
|
{
|
|
|
|
switch (light.x1c_type)
|
|
|
|
{
|
|
|
|
case ELightType::LocalAmbient:
|
2016-04-04 05:02:09 +00:00
|
|
|
m_lightingData.ambient += light.x18_color;
|
2016-07-08 03:23:58 +00:00
|
|
|
break;
|
2016-04-04 02:32:57 +00:00
|
|
|
case ELightType::Point:
|
|
|
|
case ELightType::Spot:
|
|
|
|
case ELightType::Custom:
|
|
|
|
case ELightType::Directional:
|
|
|
|
{
|
|
|
|
if (curLight >= URDE_MAX_LIGHTS)
|
|
|
|
continue;
|
|
|
|
CModelShaders::Light& lightOut = m_lightingData.lights[curLight++];
|
|
|
|
lightOut.pos = CGraphics::g_CameraMatrix * light.x0_pos;
|
2016-04-29 10:08:46 +00:00
|
|
|
lightOut.dir = CGraphics::g_CameraMatrix.basis * light.xc_dir;
|
2016-04-04 05:02:09 +00:00
|
|
|
lightOut.dir.normalize();
|
2016-04-04 02:32:57 +00:00
|
|
|
lightOut.color = light.x18_color;
|
|
|
|
lightOut.linAtt[0] = light.x24_distC;
|
|
|
|
lightOut.linAtt[1] = light.x28_distL;
|
|
|
|
lightOut.linAtt[2] = light.x2c_distQ;
|
|
|
|
lightOut.angAtt[0] = light.x30_angleC;
|
|
|
|
lightOut.angAtt[1] = light.x34_angleL;
|
|
|
|
lightOut.angAtt[2] = light.x38_angleQ;
|
2016-04-04 21:20:26 +00:00
|
|
|
|
|
|
|
if (light.x1c_type == ELightType::Directional)
|
|
|
|
lightOut.pos = (-lightOut.dir) * 1048576.f;
|
2016-04-04 02:32:57 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (; curLight<URDE_MAX_LIGHTS ; ++curLight)
|
|
|
|
{
|
|
|
|
CModelShaders::Light& lightOut = m_lightingData.lights[curLight];
|
|
|
|
lightOut.color = zeus::CColor::skClear;
|
|
|
|
lightOut.linAtt[0] = 1.f;
|
|
|
|
lightOut.angAtt[0] = 1.f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-31 02:44:43 +00:00
|
|
|
void CBooModel::RemapMaterialData(SShader& shader)
|
|
|
|
{
|
|
|
|
x4_matSet = &shader.m_matSet;
|
2016-09-02 19:32:57 +00:00
|
|
|
m_matSetIdx = shader.m_matSetIdx;
|
|
|
|
x1c_textures = shader.x0_textures;
|
2016-03-31 02:44:43 +00:00
|
|
|
m_pipelines = &shader.m_shaders;
|
|
|
|
x40_24_texturesLoaded = false;
|
|
|
|
m_gfxToken.doDestroy();
|
2016-03-29 23:14:14 +00:00
|
|
|
}
|
|
|
|
|
2016-03-31 02:44:43 +00:00
|
|
|
bool CBooModel::TryLockTextures() const
|
2016-03-30 19:16:01 +00:00
|
|
|
{
|
2016-03-31 02:44:43 +00:00
|
|
|
if (!x40_24_texturesLoaded)
|
|
|
|
{
|
|
|
|
bool allLoad = true;
|
2016-09-02 19:32:57 +00:00
|
|
|
for (TCachedToken<CTexture>& tex : const_cast<std::vector<TCachedToken<CTexture>>&>(x1c_textures))
|
2016-03-31 02:44:43 +00:00
|
|
|
{
|
|
|
|
tex.Lock();
|
|
|
|
if (!tex.IsLoaded())
|
|
|
|
allLoad = false;
|
|
|
|
}
|
|
|
|
|
2016-08-29 04:22:54 +00:00
|
|
|
const_cast<CBooModel*>(this)->x40_24_texturesLoaded = allLoad;
|
2016-03-31 02:44:43 +00:00
|
|
|
}
|
2016-09-02 21:39:46 +00:00
|
|
|
|
|
|
|
if (!m_gfxToken && x40_24_texturesLoaded)
|
|
|
|
const_cast<CBooModel*>(this)->BuildGfxToken();
|
|
|
|
|
2016-03-31 02:44:43 +00:00
|
|
|
return x40_24_texturesLoaded;
|
2016-03-30 19:16:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void CBooModel::UnlockTextures() const
|
|
|
|
{
|
2016-09-02 21:39:46 +00:00
|
|
|
const_cast<boo::GraphicsDataToken&>(m_gfxToken).doDestroy();
|
2016-09-02 19:32:57 +00:00
|
|
|
for (TCachedToken<CTexture>& tex : const_cast<std::vector<TCachedToken<CTexture>>&>(x1c_textures))
|
2016-03-31 02:44:43 +00:00
|
|
|
tex.Unlock();
|
2016-08-29 04:22:54 +00:00
|
|
|
const_cast<CBooModel*>(this)->x40_24_texturesLoaded = false;
|
2016-03-30 19:16:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void CBooModel::DrawAlphaSurfaces(const CModelFlags& flags) const
|
|
|
|
{
|
2016-04-01 01:00:37 +00:00
|
|
|
const CBooSurface* surf = x3c_firstSortedSurface;
|
|
|
|
while (surf)
|
2016-03-31 02:44:43 +00:00
|
|
|
{
|
2016-04-01 01:00:37 +00:00
|
|
|
DrawSurface(*surf, flags);
|
|
|
|
surf = surf->m_next;
|
2016-03-31 02:44:43 +00:00
|
|
|
}
|
2016-03-30 19:16:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void CBooModel::DrawNormalSurfaces(const CModelFlags& flags) const
|
|
|
|
{
|
2016-04-01 01:00:37 +00:00
|
|
|
const CBooSurface* surf = x38_firstUnsortedSurface;
|
|
|
|
while (surf)
|
2016-03-31 02:44:43 +00:00
|
|
|
{
|
2016-04-01 01:00:37 +00:00
|
|
|
DrawSurface(*surf, flags);
|
|
|
|
surf = surf->m_next;
|
2016-03-31 02:44:43 +00:00
|
|
|
}
|
2016-03-30 19:16:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void CBooModel::DrawSurfaces(const CModelFlags& flags) const
|
|
|
|
{
|
2016-03-31 02:44:43 +00:00
|
|
|
const CBooSurface* surf = x38_firstUnsortedSurface;
|
|
|
|
while (surf)
|
|
|
|
{
|
|
|
|
DrawSurface(*surf, flags);
|
|
|
|
surf = surf->m_next;
|
|
|
|
}
|
|
|
|
|
|
|
|
surf = x3c_firstSortedSurface;
|
|
|
|
while (surf)
|
|
|
|
{
|
|
|
|
DrawSurface(*surf, flags);
|
|
|
|
surf = surf->m_next;
|
|
|
|
}
|
2016-03-30 19:16:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void CBooModel::DrawSurface(const CBooSurface& surf, const CModelFlags& flags) const
|
|
|
|
{
|
2016-03-31 06:18:56 +00:00
|
|
|
const MaterialSet::Material& data = GetMaterialByIndex(surf.m_data.matIdx);
|
2016-03-31 02:44:43 +00:00
|
|
|
if (data.flags.shadowOccluderMesh() && !g_DrawingOccluders)
|
|
|
|
return;
|
|
|
|
|
2016-04-04 02:32:57 +00:00
|
|
|
const std::vector<boo::IShaderDataBinding*>& extendeds = m_shaderDataBindings[surf.selfIdx];
|
|
|
|
boo::IShaderDataBinding* binding = extendeds[0];
|
|
|
|
if (flags.m_extendedShaderIdx < extendeds.size())
|
|
|
|
binding = extendeds[flags.m_extendedShaderIdx];
|
|
|
|
|
|
|
|
CGraphics::SetShaderDataBinding(binding);
|
2016-03-31 02:44:43 +00:00
|
|
|
CGraphics::DrawArrayIndexed(surf.m_data.idxStart, surf.m_data.idxCount);
|
2016-03-30 19:16:01 +00:00
|
|
|
}
|
|
|
|
|
2016-04-04 02:32:57 +00:00
|
|
|
void CBooModel::UVAnimationBuffer::ProcessAnimation(u8*& bufOut, const UVAnimation& anim)
|
2016-03-31 06:18:56 +00:00
|
|
|
{
|
2016-07-08 19:57:51 +00:00
|
|
|
zeus::CMatrix4f& texMtxOut = reinterpret_cast<zeus::CMatrix4f&>(*bufOut);
|
2016-07-08 03:23:58 +00:00
|
|
|
zeus::CMatrix4f& postMtxOut = reinterpret_cast<zeus::CMatrix4f&>(*(bufOut + sizeof(zeus::CMatrix4f)));
|
2016-07-08 19:57:51 +00:00
|
|
|
texMtxOut = zeus::CMatrix4f();
|
|
|
|
postMtxOut = zeus::CMatrix4f();
|
2016-03-31 06:18:56 +00:00
|
|
|
switch (anim.mode)
|
|
|
|
{
|
|
|
|
case UVAnimation::Mode::MvInvNoTranslation:
|
|
|
|
{
|
2016-07-19 20:12:38 +00:00
|
|
|
texMtxOut = CGraphics::g_GXModelViewInvXpose.toMatrix4f();
|
2016-07-08 19:57:51 +00:00
|
|
|
texMtxOut.vec[3].zeroOut();
|
2016-07-19 20:12:38 +00:00
|
|
|
texMtxOut.vec[3].w = 1.f;
|
2016-07-08 20:25:38 +00:00
|
|
|
postMtxOut.vec[0].x = 0.5f;
|
2016-07-19 20:12:38 +00:00
|
|
|
postMtxOut.vec[1].y = 0.5f;
|
2016-07-08 20:25:38 +00:00
|
|
|
postMtxOut.vec[3].x = 0.5f;
|
|
|
|
postMtxOut.vec[3].y = 0.5f;
|
2016-03-31 06:18:56 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case UVAnimation::Mode::MvInv:
|
|
|
|
{
|
2016-07-19 20:12:38 +00:00
|
|
|
texMtxOut = CGraphics::g_GXModelViewInvXpose.toMatrix4f();
|
2016-07-08 20:25:38 +00:00
|
|
|
postMtxOut.vec[0].x = 0.5f;
|
2016-07-19 20:12:38 +00:00
|
|
|
postMtxOut.vec[1].y = 0.5f;
|
2016-07-08 20:25:38 +00:00
|
|
|
postMtxOut.vec[3].x = 0.5f;
|
|
|
|
postMtxOut.vec[3].y = 0.5f;
|
2016-03-31 06:18:56 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case UVAnimation::Mode::Scroll:
|
|
|
|
{
|
2016-07-08 19:57:51 +00:00
|
|
|
texMtxOut.vec[3].x = CGraphics::GetSecondsMod900() * anim.vals[2] + anim.vals[0];
|
|
|
|
texMtxOut.vec[3].y = CGraphics::GetSecondsMod900() * anim.vals[3] + anim.vals[1];
|
2016-03-31 06:18:56 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case UVAnimation::Mode::Rotation:
|
|
|
|
{
|
|
|
|
float angle = CGraphics::GetSecondsMod900() * anim.vals[1] + anim.vals[0];
|
|
|
|
float acos = std::cos(angle);
|
|
|
|
float asin = std::sin(angle);
|
2016-07-08 19:57:51 +00:00
|
|
|
texMtxOut.vec[0].x = acos;
|
|
|
|
texMtxOut.vec[0].y = asin;
|
|
|
|
texMtxOut.vec[1].x = -asin;
|
|
|
|
texMtxOut.vec[1].y = acos;
|
2016-07-09 22:02:31 +00:00
|
|
|
texMtxOut.vec[3].x = (1.0f - (acos - asin)) * 0.5f;
|
|
|
|
texMtxOut.vec[3].y = (1.0f - (asin + acos)) * 0.5f;
|
2016-03-31 06:18:56 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case UVAnimation::Mode::HStrip:
|
|
|
|
{
|
2016-07-08 19:57:51 +00:00
|
|
|
float value = anim.vals[0] * anim.vals[2] * (anim.vals[3] + CGraphics::GetSecondsMod900());
|
2016-07-09 22:02:31 +00:00
|
|
|
texMtxOut.vec[3].x = (float)(short)(float)(anim.vals[1] * fmod(value, 1.0f)) * anim.vals[2];
|
2016-03-31 06:18:56 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case UVAnimation::Mode::VStrip:
|
|
|
|
{
|
2016-07-08 19:57:51 +00:00
|
|
|
float value = anim.vals[0] * anim.vals[2] * (anim.vals[3] + CGraphics::GetSecondsMod900());
|
2016-07-09 22:02:31 +00:00
|
|
|
texMtxOut.vec[3].y = (float)(short)(float)(anim.vals[1] * fmod(value, 1.0f)) * anim.vals[2];
|
2016-03-31 06:18:56 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case UVAnimation::Mode::Model:
|
|
|
|
{
|
2016-07-08 20:25:38 +00:00
|
|
|
texMtxOut = CGraphics::g_GXModelMatrix.toMatrix4f();
|
|
|
|
texMtxOut.vec[3].zeroOut();
|
|
|
|
|
|
|
|
postMtxOut.vec[0].x = 0.5f;
|
|
|
|
postMtxOut.vec[2].y = 0.5f;
|
|
|
|
postMtxOut.vec[3].x = CGraphics::g_GXModelMatrix.origin.x * 0.5f;
|
|
|
|
postMtxOut.vec[3].y = CGraphics::g_GXModelMatrix.origin.y * 0.5f;
|
2016-03-31 06:18:56 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case UVAnimation::Mode::WhoMustNotBeNamed:
|
|
|
|
{
|
2016-07-08 20:25:38 +00:00
|
|
|
texMtxOut = (CGraphics::g_ViewMatrix.inverse() * CGraphics::g_GXModelMatrix).toMatrix4f();
|
|
|
|
texMtxOut.vec[3].zeroOut();
|
2016-07-08 03:23:58 +00:00
|
|
|
|
|
|
|
const zeus::CVector3f& viewOrigin = CGraphics::g_ViewMatrix.origin;
|
|
|
|
float xy = (viewOrigin.x + viewOrigin.y) * 0.025f * anim.vals[1];
|
|
|
|
xy = (xy - (int)xy);
|
|
|
|
float z = (viewOrigin.z) * 0.05f * anim.vals[1];
|
|
|
|
z = (z - (int)z);
|
|
|
|
|
|
|
|
float halfA = anim.vals[0] * 0.5f;
|
|
|
|
|
|
|
|
postMtxOut = zeus::CTransform(zeus::CMatrix3f(halfA, 0.0, 0.0,
|
|
|
|
0.0, 0.0, halfA,
|
|
|
|
0.0, 0.0, 0.0),
|
|
|
|
zeus::CVector3f(xy, z, 1.0)).toMatrix4f();
|
2016-03-31 06:18:56 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default: break;
|
|
|
|
}
|
2016-07-08 06:53:06 +00:00
|
|
|
bufOut += sizeof(zeus::CMatrix4f) * 2;
|
2016-03-31 06:18:56 +00:00
|
|
|
}
|
|
|
|
|
2016-04-04 02:32:57 +00:00
|
|
|
void CBooModel::UVAnimationBuffer::PadOutBuffer(u8*& bufStart, u8*& bufOut)
|
2016-03-31 06:18:56 +00:00
|
|
|
{
|
2016-04-04 02:32:57 +00:00
|
|
|
bufOut = bufStart + ROUND_UP_256(bufOut - bufStart);
|
2016-03-31 06:18:56 +00:00
|
|
|
}
|
|
|
|
|
2016-07-31 02:06:47 +00:00
|
|
|
void CBooModel::UVAnimationBuffer::Update(u8*& bufOut, const MaterialSet* matSet, const CModelFlags& flags)
|
2016-03-31 06:18:56 +00:00
|
|
|
{
|
2016-04-04 02:32:57 +00:00
|
|
|
u8* start = bufOut;
|
2016-03-31 06:18:56 +00:00
|
|
|
|
2016-07-31 02:06:47 +00:00
|
|
|
/* Special Mode0 matrix for exclusive Thermal Visor use */
|
|
|
|
std::experimental::optional<std::array<zeus::CMatrix4f, 2>> thermalMtxOut;
|
|
|
|
if (flags.m_extendedShaderIdx == 2)
|
|
|
|
{
|
|
|
|
thermalMtxOut.emplace();
|
|
|
|
|
|
|
|
zeus::CMatrix4f& texMtxOut = (*thermalMtxOut)[0];
|
|
|
|
texMtxOut = CGraphics::g_GXModelViewInvXpose.toMatrix4f();
|
|
|
|
texMtxOut.vec[3].zeroOut();
|
|
|
|
texMtxOut.vec[3].w = 1.f;
|
|
|
|
|
|
|
|
zeus::CMatrix4f& postMtxOut = (*thermalMtxOut)[1];
|
|
|
|
postMtxOut.vec[0].x = 0.5f;
|
|
|
|
postMtxOut.vec[1].y = 0.5f;
|
|
|
|
postMtxOut.vec[3].x = 0.5f;
|
|
|
|
postMtxOut.vec[3].y = 0.5f;
|
|
|
|
}
|
|
|
|
|
2016-03-31 06:18:56 +00:00
|
|
|
for (const MaterialSet::Material& mat : matSet->materials)
|
|
|
|
{
|
2016-07-31 02:06:47 +00:00
|
|
|
if (thermalMtxOut)
|
|
|
|
{
|
|
|
|
std::array<zeus::CMatrix4f, 2>* mtxs = reinterpret_cast<std::array<zeus::CMatrix4f, 2>*>(bufOut);
|
|
|
|
mtxs[7][0] = (*thermalMtxOut)[0];
|
|
|
|
mtxs[7][1] = (*thermalMtxOut)[1];
|
|
|
|
}
|
|
|
|
u8* bufOrig = bufOut;
|
2016-03-31 06:18:56 +00:00
|
|
|
for (const UVAnimation& anim : mat.uvAnims)
|
2016-04-04 02:32:57 +00:00
|
|
|
ProcessAnimation(bufOut, anim);
|
2016-07-31 04:46:03 +00:00
|
|
|
bufOut = bufOrig + sizeof(zeus::CMatrix4f) * 2 * 8;
|
2016-04-04 02:32:57 +00:00
|
|
|
PadOutBuffer(start, bufOut);
|
2016-03-31 06:18:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-21 20:39:18 +00:00
|
|
|
void CBooModel::UpdateUniformData(const CModelFlags& flags,
|
|
|
|
const CSkinRules* cskr,
|
|
|
|
const CPoseAsTransforms* pose) const
|
2016-03-31 06:18:56 +00:00
|
|
|
{
|
2016-08-31 23:31:12 +00:00
|
|
|
if (!m_uniformBuffer)
|
|
|
|
return;
|
|
|
|
|
2016-04-04 19:34:54 +00:00
|
|
|
u8* dataOut = reinterpret_cast<u8*>(m_uniformBuffer->map(m_uniformDataSize));
|
|
|
|
u8* dataCur = dataOut;
|
2016-03-31 06:18:56 +00:00
|
|
|
|
2016-04-04 02:32:57 +00:00
|
|
|
if (m_skinBankCount)
|
2016-03-31 21:06:41 +00:00
|
|
|
{
|
2016-04-04 02:32:57 +00:00
|
|
|
/* Skinned */
|
2016-08-21 20:39:18 +00:00
|
|
|
std::vector<const zeus::CTransform*> bankTransforms;
|
|
|
|
bankTransforms.reserve(m_weightVecCount*4);
|
2016-04-04 02:32:57 +00:00
|
|
|
for (size_t i=0 ; i<m_skinBankCount ; ++i)
|
|
|
|
{
|
2016-08-21 20:39:18 +00:00
|
|
|
if (cskr && pose)
|
2016-04-04 02:32:57 +00:00
|
|
|
{
|
2016-08-21 20:39:18 +00:00
|
|
|
cskr->GetBankTransforms(bankTransforms, *pose, i);
|
|
|
|
|
|
|
|
for (size_t w=0 ; w<m_weightVecCount*4 ; ++w)
|
|
|
|
{
|
|
|
|
zeus::CMatrix4f& mv = reinterpret_cast<zeus::CMatrix4f&>(*dataCur);
|
|
|
|
if (w >= bankTransforms.size())
|
|
|
|
mv = CGraphics::g_GXModelView.toMatrix4f();
|
|
|
|
else
|
|
|
|
mv = (CGraphics::g_GXModelView * *bankTransforms[w]).toMatrix4f();
|
|
|
|
dataCur += sizeof(zeus::CMatrix4f);
|
|
|
|
}
|
|
|
|
for (size_t w=0 ; w<m_weightVecCount*4 ; ++w)
|
|
|
|
{
|
|
|
|
zeus::CMatrix4f& mvinv = reinterpret_cast<zeus::CMatrix4f&>(*dataCur);
|
|
|
|
if (w >= bankTransforms.size())
|
|
|
|
mvinv = CGraphics::g_GXModelViewInvXpose.toMatrix4f();
|
|
|
|
else
|
|
|
|
{
|
|
|
|
zeus::CTransform xf = (CGraphics::g_GXModelView * *bankTransforms[w]).inverse();
|
|
|
|
xf.origin.zeroOut();
|
|
|
|
xf.basis.transpose();
|
|
|
|
mvinv = xf.toMatrix4f();
|
|
|
|
}
|
|
|
|
dataCur += sizeof(zeus::CMatrix4f);
|
|
|
|
}
|
|
|
|
|
|
|
|
bankTransforms.clear();
|
2016-04-04 02:32:57 +00:00
|
|
|
}
|
2016-08-21 20:39:18 +00:00
|
|
|
else
|
2016-04-04 02:32:57 +00:00
|
|
|
{
|
2016-08-21 20:39:18 +00:00
|
|
|
for (size_t w=0 ; w<m_weightVecCount*4 ; ++w)
|
|
|
|
{
|
|
|
|
zeus::CMatrix4f& mv = reinterpret_cast<zeus::CMatrix4f&>(*dataCur);
|
|
|
|
mv = CGraphics::g_GXModelView.toMatrix4f();
|
|
|
|
dataCur += sizeof(zeus::CMatrix4f);
|
|
|
|
}
|
|
|
|
for (size_t w=0 ; w<m_weightVecCount*4 ; ++w)
|
|
|
|
{
|
|
|
|
zeus::CMatrix4f& mvinv = reinterpret_cast<zeus::CMatrix4f&>(*dataCur);
|
|
|
|
mvinv = CGraphics::g_GXModelViewInvXpose.toMatrix4f();
|
|
|
|
dataCur += sizeof(zeus::CMatrix4f);
|
|
|
|
}
|
2016-04-04 02:32:57 +00:00
|
|
|
}
|
2016-04-04 19:34:54 +00:00
|
|
|
zeus::CMatrix4f& proj = reinterpret_cast<zeus::CMatrix4f&>(*dataCur);
|
2016-04-04 02:32:57 +00:00
|
|
|
proj = CGraphics::GetPerspectiveProjectionMatrix(true);
|
2016-04-04 19:34:54 +00:00
|
|
|
dataCur += sizeof(zeus::CMatrix4f);
|
2016-04-04 02:32:57 +00:00
|
|
|
|
2016-04-04 19:34:54 +00:00
|
|
|
dataCur = dataOut + ROUND_UP_256(dataCur - dataOut);
|
2016-04-04 02:32:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Non-Skinned */
|
2016-04-04 19:34:54 +00:00
|
|
|
zeus::CMatrix4f& mv = reinterpret_cast<zeus::CMatrix4f&>(*dataCur);
|
2016-04-04 02:32:57 +00:00
|
|
|
mv = CGraphics::g_GXModelView.toMatrix4f();
|
2016-04-04 19:34:54 +00:00
|
|
|
dataCur += sizeof(zeus::CMatrix4f);
|
2016-04-04 02:32:57 +00:00
|
|
|
|
2016-04-04 19:34:54 +00:00
|
|
|
zeus::CMatrix4f& mvinv = reinterpret_cast<zeus::CMatrix4f&>(*dataCur);
|
2016-04-04 02:32:57 +00:00
|
|
|
mvinv = CGraphics::g_GXModelViewInvXpose.toMatrix4f();
|
2016-04-04 19:34:54 +00:00
|
|
|
dataCur += sizeof(zeus::CMatrix4f);
|
2016-04-04 02:32:57 +00:00
|
|
|
|
2016-04-04 19:34:54 +00:00
|
|
|
zeus::CMatrix4f& proj = reinterpret_cast<zeus::CMatrix4f&>(*dataCur);
|
2016-04-04 02:32:57 +00:00
|
|
|
proj = CGraphics::GetPerspectiveProjectionMatrix(true);
|
2016-04-04 19:34:54 +00:00
|
|
|
dataCur += sizeof(zeus::CMatrix4f);
|
2016-04-04 02:32:57 +00:00
|
|
|
|
2016-04-04 19:34:54 +00:00
|
|
|
dataCur = dataOut + ROUND_UP_256(dataCur - dataOut);
|
2016-03-31 21:06:41 +00:00
|
|
|
}
|
2016-04-04 02:32:57 +00:00
|
|
|
|
2016-07-31 02:06:47 +00:00
|
|
|
UVAnimationBuffer::Update(dataCur, x4_matSet, flags);
|
2016-04-04 02:32:57 +00:00
|
|
|
|
2016-07-31 02:06:47 +00:00
|
|
|
if (flags.m_extendedShaderIdx == 2) /* Thermal Model (same as UV Mode 0) */
|
|
|
|
{
|
|
|
|
CModelShaders::ThermalUniform& thermalOut = *reinterpret_cast<CModelShaders::ThermalUniform*>(dataCur);
|
|
|
|
thermalOut.mulColor = flags.color;
|
|
|
|
thermalOut.addColor = flags.addColor;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
CModelShaders::LightingUniform& lightingOut = *reinterpret_cast<CModelShaders::LightingUniform*>(dataCur);
|
|
|
|
lightingOut = m_lightingData;
|
2016-08-01 06:36:51 +00:00
|
|
|
lightingOut.colorRegs[0] = flags.regColors[0];
|
|
|
|
lightingOut.colorRegs[1] = flags.regColors[1];
|
|
|
|
lightingOut.colorRegs[2] = flags.regColors[2];
|
2016-08-08 04:48:18 +00:00
|
|
|
lightingOut.fog = CGraphics::g_Fog;
|
2016-07-31 02:06:47 +00:00
|
|
|
}
|
2016-04-04 02:32:57 +00:00
|
|
|
|
2016-04-04 19:34:54 +00:00
|
|
|
m_uniformBuffer->unmap();
|
2016-07-31 02:06:47 +00:00
|
|
|
}
|
2016-03-31 06:18:56 +00:00
|
|
|
|
2016-08-21 20:39:18 +00:00
|
|
|
void CBooModel::DrawAlpha(const CModelFlags& flags,
|
|
|
|
const CSkinRules* cskr,
|
|
|
|
const CPoseAsTransforms* pose) const
|
2016-03-30 19:16:01 +00:00
|
|
|
{
|
2016-04-01 01:00:37 +00:00
|
|
|
if (TryLockTextures())
|
|
|
|
{
|
2016-08-21 20:39:18 +00:00
|
|
|
UpdateUniformData(flags, cskr, pose);
|
2016-04-01 01:00:37 +00:00
|
|
|
DrawAlphaSurfaces(flags);
|
|
|
|
}
|
2016-03-30 19:16:01 +00:00
|
|
|
}
|
|
|
|
|
2016-08-21 20:39:18 +00:00
|
|
|
void CBooModel::DrawNormal(const CModelFlags& flags,
|
|
|
|
const CSkinRules* cskr,
|
|
|
|
const CPoseAsTransforms* pose) const
|
2016-03-30 19:16:01 +00:00
|
|
|
{
|
2016-04-01 01:00:37 +00:00
|
|
|
if (TryLockTextures())
|
|
|
|
{
|
2016-08-21 20:39:18 +00:00
|
|
|
UpdateUniformData(flags, cskr, pose);
|
2016-04-01 01:00:37 +00:00
|
|
|
DrawNormalSurfaces(flags);
|
|
|
|
}
|
2016-03-30 19:16:01 +00:00
|
|
|
}
|
|
|
|
|
2016-08-21 20:39:18 +00:00
|
|
|
void CBooModel::Draw(const CModelFlags& flags,
|
|
|
|
const CSkinRules* cskr,
|
|
|
|
const CPoseAsTransforms* pose) const
|
2016-03-30 19:16:01 +00:00
|
|
|
{
|
2016-04-01 01:00:37 +00:00
|
|
|
if (TryLockTextures())
|
|
|
|
{
|
2016-08-21 20:39:18 +00:00
|
|
|
UpdateUniformData(flags, cskr, pose);
|
2016-04-01 01:00:37 +00:00
|
|
|
DrawSurfaces(flags);
|
|
|
|
}
|
2016-03-29 23:14:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const u8* MemoryFromPartData(const u8*& dataCur, const s32*& secSizeCur)
|
|
|
|
{
|
|
|
|
const u8* ret;
|
|
|
|
if (*secSizeCur)
|
|
|
|
ret = dataCur;
|
|
|
|
else
|
|
|
|
ret = nullptr;
|
|
|
|
|
|
|
|
dataCur += hecl::SBig(*secSizeCur);
|
|
|
|
++secSizeCur;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-04-05 01:51:25 +00:00
|
|
|
std::unique_ptr<CBooModel> CModel::MakeNewInstance(int shaderIdx)
|
2016-03-29 23:14:14 +00:00
|
|
|
{
|
2016-04-05 01:51:25 +00:00
|
|
|
if (shaderIdx >= x18_matSets.size())
|
|
|
|
shaderIdx = 0;
|
2016-09-02 19:32:57 +00:00
|
|
|
return std::make_unique<CBooModel>(m_selfToken, &x8_surfaces, x18_matSets[shaderIdx],
|
2016-04-05 01:51:25 +00:00
|
|
|
m_vtxFmt, m_vbo, m_ibo, 0, 0, m_aabb);
|
|
|
|
}
|
|
|
|
|
2016-09-02 19:32:57 +00:00
|
|
|
CModel::CModel(std::unique_ptr<u8[]>&& in, u32 /* dataLen */, IObjectStore* store, CObjectReference* selfRef)
|
|
|
|
: m_selfToken(selfRef)
|
2016-04-05 01:51:25 +00:00
|
|
|
{
|
|
|
|
std::unique_ptr<u8[]> data = std::move(in);
|
|
|
|
|
|
|
|
u32 version = hecl::SBig(*reinterpret_cast<u32*>(data.get() + 0x4));
|
|
|
|
u32 flags = hecl::SBig(*reinterpret_cast<u32*>(data.get() + 0x8));
|
2016-03-31 21:06:41 +00:00
|
|
|
if (version != 0x10002)
|
2016-03-29 23:14:14 +00:00
|
|
|
Log.report(logvisor::Fatal, "invalid CMDL for loading with boo");
|
|
|
|
|
2016-04-05 01:51:25 +00:00
|
|
|
u32 secCount = hecl::SBig(*reinterpret_cast<u32*>(data.get() + 0x24));
|
|
|
|
u32 matSetCount = hecl::SBig(*reinterpret_cast<u32*>(data.get() + 0x28));
|
2016-03-29 23:14:14 +00:00
|
|
|
x18_matSets.reserve(matSetCount);
|
2016-04-05 01:51:25 +00:00
|
|
|
const u8* dataCur = data.get() + ROUND_UP_32(0x2c + secCount * 4);
|
|
|
|
const s32* secSizeCur = reinterpret_cast<const s32*>(data.get() + 0x2c);
|
2016-03-29 23:14:14 +00:00
|
|
|
for (u32 i=0 ; i<matSetCount ; ++i)
|
|
|
|
{
|
2016-03-31 02:44:43 +00:00
|
|
|
u32 matSetSz = hecl::SBig(*secSizeCur);
|
2016-03-29 23:14:14 +00:00
|
|
|
const u8* sec = MemoryFromPartData(dataCur, secSizeCur);
|
2016-09-02 19:32:57 +00:00
|
|
|
x18_matSets.emplace_back(i);
|
2016-03-31 02:44:43 +00:00
|
|
|
CBooModel::SShader& shader = x18_matSets.back();
|
|
|
|
athena::io::MemoryReader r(sec, matSetSz);
|
|
|
|
shader.m_matSet.read(r);
|
|
|
|
CBooModel::MakeTexuresFromMats(shader.m_matSet, shader.x0_textures, *store);
|
2016-03-29 23:14:14 +00:00
|
|
|
}
|
|
|
|
|
2016-03-30 19:16:01 +00:00
|
|
|
hecl::HMDLMeta hmdlMeta;
|
|
|
|
{
|
2016-03-31 02:44:43 +00:00
|
|
|
u32 hmdlSz = hecl::SBig(*secSizeCur);
|
2016-03-30 19:16:01 +00:00
|
|
|
const u8* hmdlMetadata = MemoryFromPartData(dataCur, secSizeCur);
|
2016-03-31 02:44:43 +00:00
|
|
|
athena::io::MemoryReader r(hmdlMetadata, hmdlSz);
|
2016-03-30 19:16:01 +00:00
|
|
|
hmdlMeta.read(r);
|
|
|
|
}
|
|
|
|
|
2016-03-29 23:14:14 +00:00
|
|
|
const u8* vboData = MemoryFromPartData(dataCur, secSizeCur);
|
|
|
|
const u8* iboData = MemoryFromPartData(dataCur, secSizeCur);
|
|
|
|
const u8* surfInfo = MemoryFromPartData(dataCur, secSizeCur);
|
|
|
|
|
2016-03-30 19:16:01 +00:00
|
|
|
m_gfxToken = CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) -> bool
|
|
|
|
{
|
2016-07-22 02:32:23 +00:00
|
|
|
m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, vboData, hmdlMeta.vertStride, hmdlMeta.vertCount);
|
|
|
|
m_ibo = ctx.newStaticBuffer(boo::BufferUse::Index, iboData, 4, hmdlMeta.indexCount);
|
|
|
|
m_vtxFmt = hecl::Runtime::HMDLData::NewVertexFormat(ctx, hmdlMeta, m_vbo, m_ibo);
|
2016-03-31 02:44:43 +00:00
|
|
|
|
2016-07-22 02:32:23 +00:00
|
|
|
for (CBooModel::SShader& matSet : x18_matSets)
|
|
|
|
{
|
2016-03-31 02:44:43 +00:00
|
|
|
matSet.m_shaders.reserve(matSet.m_matSet.materials.size());
|
2016-03-31 06:18:56 +00:00
|
|
|
for (const MaterialSet::Material& mat : matSet.m_matSet.materials)
|
2016-07-22 02:32:23 +00:00
|
|
|
{
|
|
|
|
hecl::Runtime::ShaderTag tag(mat.heclIr,
|
|
|
|
hmdlMeta.colorCount, hmdlMeta.uvCount, hmdlMeta.weightCount,
|
2016-07-31 02:06:47 +00:00
|
|
|
0, 8, boo::Primitive(hmdlMeta.topology),
|
2016-07-22 02:32:23 +00:00
|
|
|
true, true, true);
|
|
|
|
matSet.m_shaders.push_back(CModelShaders::g_ModelShaders->buildExtendedShader(tag, mat.heclIr, "CMDL", ctx));
|
|
|
|
}
|
|
|
|
}
|
2016-03-31 02:44:43 +00:00
|
|
|
|
2016-07-22 02:32:23 +00:00
|
|
|
return true;
|
|
|
|
});
|
2016-03-30 19:16:01 +00:00
|
|
|
|
2016-03-29 23:14:14 +00:00
|
|
|
u32 surfCount = hecl::SBig(*reinterpret_cast<const u32*>(surfInfo));
|
|
|
|
x8_surfaces.reserve(surfCount);
|
|
|
|
for (u32 i=0 ; i<surfCount ; ++i)
|
|
|
|
{
|
2016-03-31 02:44:43 +00:00
|
|
|
u32 surfSz = hecl::SBig(*secSizeCur);
|
2016-03-29 23:14:14 +00:00
|
|
|
const u8* sec = MemoryFromPartData(dataCur, secSizeCur);
|
|
|
|
x8_surfaces.emplace_back();
|
2016-03-31 02:44:43 +00:00
|
|
|
CBooSurface& surf = x8_surfaces.back();
|
2016-04-04 02:32:57 +00:00
|
|
|
surf.selfIdx = i;
|
2016-03-31 02:44:43 +00:00
|
|
|
athena::io::MemoryReader r(sec, surfSz);
|
|
|
|
surf.m_data.read(r);
|
2016-03-29 23:14:14 +00:00
|
|
|
}
|
|
|
|
|
2016-04-05 01:51:25 +00:00
|
|
|
const float* aabbPtr = reinterpret_cast<const float*>(data.get() + 0xc);
|
|
|
|
m_aabb = zeus::CAABox(hecl::SBig(aabbPtr[0]), hecl::SBig(aabbPtr[1]), hecl::SBig(aabbPtr[2]),
|
2016-07-08 03:23:58 +00:00
|
|
|
hecl::SBig(aabbPtr[3]), hecl::SBig(aabbPtr[4]), hecl::SBig(aabbPtr[5]));
|
2016-04-05 01:51:25 +00:00
|
|
|
x28_modelInst = MakeNewInstance(0);
|
2016-03-29 23:14:14 +00:00
|
|
|
}
|
2016-02-13 00:57:09 +00:00
|
|
|
|
2016-03-31 02:44:43 +00:00
|
|
|
void CBooModel::SShader::UnlockTextures()
|
|
|
|
{
|
|
|
|
for (TCachedToken<CTexture>& tex : x0_textures)
|
|
|
|
tex.Unlock();
|
|
|
|
}
|
|
|
|
|
2016-09-02 19:32:57 +00:00
|
|
|
void CBooModel::VerifyCurrentShader(int shaderIdx)
|
2016-03-31 02:44:43 +00:00
|
|
|
{
|
2016-09-02 19:32:57 +00:00
|
|
|
if (shaderIdx != m_matSetIdx)
|
|
|
|
RemapMaterialData(m_model->x18_matSets[shaderIdx]);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CBooModel::Touch(int shaderIdx) const
|
|
|
|
{
|
|
|
|
const_cast<CBooModel*>(this)->VerifyCurrentShader(shaderIdx);
|
|
|
|
TryLockTextures();
|
2016-03-31 02:44:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void CModel::DrawSortedParts(const CModelFlags& flags) const
|
|
|
|
{
|
2016-09-02 19:32:57 +00:00
|
|
|
const_cast<CBooModel&>(*x28_modelInst).VerifyCurrentShader(flags.m_matSetIdx);
|
2016-08-21 20:39:18 +00:00
|
|
|
x28_modelInst->DrawAlpha(flags, nullptr, nullptr);
|
2016-03-31 02:44:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void CModel::DrawUnsortedParts(const CModelFlags& flags) const
|
|
|
|
{
|
2016-09-02 19:32:57 +00:00
|
|
|
const_cast<CBooModel&>(*x28_modelInst).VerifyCurrentShader(flags.m_matSetIdx);
|
2016-08-21 20:39:18 +00:00
|
|
|
x28_modelInst->DrawNormal(flags, nullptr, nullptr);
|
2016-03-31 02:44:43 +00:00
|
|
|
}
|
|
|
|
|
2016-02-13 00:57:09 +00:00
|
|
|
void CModel::Draw(const CModelFlags& flags) const
|
|
|
|
{
|
2016-09-02 19:32:57 +00:00
|
|
|
const_cast<CBooModel&>(*x28_modelInst).VerifyCurrentShader(flags.m_matSetIdx);
|
2016-08-21 20:39:18 +00:00
|
|
|
x28_modelInst->Draw(flags, nullptr, nullptr);
|
2016-02-13 00:57:09 +00:00
|
|
|
}
|
|
|
|
|
2016-03-31 02:44:43 +00:00
|
|
|
bool CModel::IsLoaded(int shaderIdx) const
|
2016-03-17 02:18:01 +00:00
|
|
|
{
|
2016-09-02 19:32:57 +00:00
|
|
|
const_cast<CBooModel&>(*x28_modelInst).VerifyCurrentShader(shaderIdx);
|
|
|
|
std::vector<TCachedToken<CTexture>>& texs = x28_modelInst->x1c_textures;
|
2016-03-31 06:18:56 +00:00
|
|
|
bool loaded = true;
|
2016-09-02 19:32:57 +00:00
|
|
|
for (TCachedToken<CTexture>& tex : texs)
|
2016-03-31 06:18:56 +00:00
|
|
|
{
|
|
|
|
if (!tex.IsLoaded())
|
|
|
|
{
|
|
|
|
loaded = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return loaded;
|
2016-03-17 02:18:01 +00:00
|
|
|
}
|
|
|
|
|
2016-03-29 23:14:14 +00:00
|
|
|
CFactoryFnReturn FModelFactory(const urde::SObjectTag& tag,
|
|
|
|
std::unique_ptr<u8[]>&& in, u32 len,
|
2016-09-02 19:32:57 +00:00
|
|
|
const urde::CVParamTransfer& vparms,
|
|
|
|
CObjectReference* selfRef)
|
2016-03-29 23:14:14 +00:00
|
|
|
{
|
|
|
|
IObjectStore* store = static_cast<TObjOwnerParam<IObjectStore*>*>(vparms.GetObj())->GetParam();
|
2016-09-02 19:32:57 +00:00
|
|
|
CFactoryFnReturn ret = TToken<CModel>::GetIObjObjectFor(std::make_unique<CModel>(std::move(in), len, store, selfRef));
|
2016-04-01 01:00:37 +00:00
|
|
|
return ret;
|
2016-03-29 23:14:14 +00:00
|
|
|
}
|
|
|
|
|
2016-02-13 00:57:09 +00:00
|
|
|
}
|