IZ_BOOL CShaderProgramDX9::SetValue(CGraphicsDevice* device, const SHADER_PARAM_HANDLE& handle, const void* p, IZ_UINT size)
{
IZ_ASSERT(IsValid());
IZ_ASSERT(device->GetShaderProgram() == this);
_EXEC_ARRAY_FUNC(SetValue, device, p, size);
}
/**
* アンロック
*/
IZ_BOOL CVertexBufferOGL::Unlock(CGraphicsDevice* device)
{
IZ_ASSERT(s_isLocked);
IZ_ASSERT(m_VB > 0);
IZ_BOOL isLocked = m_isLocked;
if (isLocked) {
#if 0
CALL_GL_API(glUnmapBuffer(GL_COPY_WRITE_BUFFER));
CALL_GL_API(glBindBuffer(
GL_COPY_WRITE_BUFFER,
0));
#else
CALL_GL_API(glUnmapNamedBuffer(m_VB));
#endif
m_prevVB = 0;
m_isLocked = IZ_FALSE;
}
s_isLocked = IZ_FALSE;
return isLocked;
}
StateMachineNode* AnimationStateMachine::next()
{
// 入ってきたノードに遷移するビヘイビアを探す.
IZ_ASSERT(m_fromBehaviour != nullptr);
auto from = m_fromBehaviour->getFrom();
IZ_ASSERT(from != nullptr);
auto item = m_behaviours.GetTop();
while (item) {
auto behaviour = item->GetData();
auto to = behaviour->getTo();
if (from == to) {
return behaviour;
}
item = item->GetNext();
}
IZ_ASSERT(IZ_FALSE);
return nullptr;
}
IZ_BOOL CShaderProgramDX9::SetVector(CGraphicsDevice* device, const SHADER_PARAM_HANDLE& handle, const math::SVector4& v)
{
IZ_ASSERT(IsValid());
IZ_ASSERT(device->GetShaderProgram() == this);
_EXEC_FUNC(SetVector, device, v);
}
/**
* Initialize memory allocator.
*/
IZ_BOOL CChunkedMemoryAllocator::Init(IZ_UINT nBufSize, void* pBuf, IZ_UINT nChunkSize)
{
IZ_ASSERT(!m_AllocList.HasItem());
IZ_ASSERT(nChunkSize > 0);
m_FreeList.Clear();
IZ_BOOL ret = IZ_FALSE;
m_nBufSize = nBufSize;
m_pBuf = reinterpret_cast<IZ_UINT8*>(pBuf);
// ChunkSize must be power of 2.
m_nChunkSize = math::CMath::ComputeNextPow2(nChunkSize);
// フリーリスト初期化
SHeapHeader* p = GetHeapHeader(m_pBuf);
if (p != IZ_NULL) {
p->buf = m_pBuf + sizeof(SHeapHeader);
p->size = m_nBufSize - sizeof(SHeapHeader);
m_FreeList.AddTop(p);
ret = IZ_TRUE;
}
return ret;
}
AnimationStateMachineBehaviour* AnimationStateMachine::addBehaviour(
const char* from,
const char* to,
izanagi::CAnimationInterp::E_INTERP_TYPE interpType/*= izanagi::CAnimationInterp::E_INTERP_TYPE::E_INTERP_TYPE_SMOOTH*/)
{
IZ_ASSERT(from || to);
AnimationStateMachineNode* fromNode = nullptr;
AnimationStateMachineNode* toNode = nullptr;
if (from) {
IZ_ASSERT(strlen(from) > 0);
if (m_entry.getName() != from) {
fromNode = getNode(from);
}
}
if (to) {
IZ_ASSERT(strlen(to) > 0);
if (m_exit.getName() != to) {
toNode = getNode(to);
}
}
auto ret = addBehaviour(
fromNode, toNode,
interpType);
return ret;
}
// シェーダごとの初期化
BOOL CHemiLightShader::InitInternal(izanagi::graph::CGraphicsDevice* pDevice)
{
UNUSED_ALWAYS(pDevice);
IZ_ASSERT(m_pEffect != IZ_NULL);
if (!GetCommonParameterHandles()) {
return IZ_FALSE;
}
static const char* PARAM_NAME[] = {
"g_vEye",
"g_vMtrlDiffuse",
"g_vAxis",
"g_vUpColor",
"g_vDownColor",
};
C_ASSERT(COUNTOF(PARAM_NAME) == HANDLE_NUM);
IZ_BOOL result = GetParameterByName(
HANDLE_NUM,
m_hHandles,
PARAM_NAME);
IZ_ASSERT(result);
return result;
}
IZ_INT AssimpImporter::GetJointParent(
IZ_UINT nIdx,
const std::vector<izanagi::S_SKL_JOINT>& tvJoint)
{
auto it = m_nodes.find(nIdx);
IZ_INT ret = -1;
if (it != m_nodes.end()) {
const Node& node = it->second;
auto parentId = node.parent;
if (parentId >= 0) {
auto itParent = m_nodes.find(parentId);
IZ_ASSERT(itParent != m_nodes.end());
const Node& parentNode = itParent->second;
if (parentNode.node == node.node->mParent) {
ret = parentId;
}
else {
IZ_ASSERT(IZ_FALSE);
}
}
}
return ret;
}
IZ_BOOL CTextureOGL::Write(
IZ_UINT level,
void* data,
IZ_UINT x, IZ_UINT y,
IZ_UINT width, IZ_UINT height)
{
IZ_ASSERT(m_Texture != 0);
// Check not locked.
IZ_ASSERT(m_LockedSize == 0);
IZ_ASSERT(x < width);
IZ_ASSERT(y < height);
IZ_UINT w = GetWidth(level);
IZ_UINT h = GetHeight(level);
VRETURN(width <= w);
VRETURN(height <= h);
CALL_GL_API(::glTextureSubImage2D(
m_Texture,
level,
x, y,
width, height,
m_GLFormat,
m_GLType,
data));
return IZ_TRUE;
}
IZ_BOOL CShaderProgramDX9::SetMatrix(CGraphicsDevice* device, const SHADER_PARAM_HANDLE& handle, const math::SMatrix44& m)
{
IZ_ASSERT(IsValid());
IZ_ASSERT(device->GetShaderProgram() == this);
_EXEC_FUNC(SetMatrix, device, m);
}
IZ_BOOL CStateBasic::Enter(izanagi::IMemoryAllocator* allocator, void* val)
{
izanagi::graph::CGraphicsDevice* pDevice = CMySystem::GetInstance().GetGraphicsDevice();
izanagi::IMemoryAllocator* pAllocator = CMySystem::GetInstance().GetMemoryAllocator();
// シェーダ
m_pShader = CShaderBase::CreateShader<CBasicShader>(
pAllocator,
pDevice,
"./data/BasicShader.bin");
IZ_ASSERT(m_pShader != IZ_NULL);
// グリッド
m_pGrid = izanagi::CDebugMeshGrid::CreateDebugMeshGrid(
pAllocator,
pDevice,
0xffffffff,
20, 20,
10.0f);
IZ_ASSERT(m_pGrid != IZ_NULL);
// 球
m_pSphere = izanagi::CDebugMeshSphere::CreateDebugMeshSphere(
pAllocator,
pDevice,
izanagi::E_DEBUG_MESH_VTX_FORM_POS | izanagi::E_DEBUG_MESH_VTX_FORM_COLOR | izanagi::E_DEBUG_MESH_VTX_FORM_UV,
0xffffffff,
5.0f,
50, 50);
IZ_ASSERT(m_pSphere != IZ_NULL);
return IZ_TRUE;
}
IZ_BOOL CShaderProgramDX9::SetInt(CGraphicsDevice* device, const SHADER_PARAM_HANDLE& handle, IZ_INT n)
{
IZ_ASSERT(IsValid());
IZ_ASSERT(device->GetShaderProgram() == this);
_EXEC_FUNC(SetInt, device, n);
}
IZ_BOOL CShaderProgramDX9::SetIntArray(CGraphicsDevice* device, const SHADER_PARAM_HANDLE& handle, const IZ_INT* n, IZ_UINT num)
{
IZ_ASSERT(IsValid());
IZ_ASSERT(device->GetShaderProgram() == this);
_EXEC_ARRAY_FUNC(SetIntArray, device, n, num);
}
BOOL CFileIdCreator::Export(LPCSTR lpszExport)
{
FILE* fpOut = NULL;
fopen_s(&fpOut, lpszExport, "wt");
VRETURN(fpOut != NULL);
m_bIsEnum = FALSE;
UINT nRootKey = izanagi::CKey::GenerateValue(m_strRoot);
std::map<UINT, SIdInfo>::const_iterator it = m_InfoList.find(nRootKey);
IZ_ASSERT(it != m_InfoList.end());
const SIdInfo& sRootInfo = it->second;
BOOL ret = Export(
fpOut,
sRootInfo,
0);
IZ_ASSERT(ret);
fclose(fpOut);
return ret;
}
// レンダーターゲットセット
IZ_BOOL CGraphicsDevice::PushRenderTarget(CRenderTarget** rt, IZ_UINT num)
{
IZ_ASSERT(rt != IZ_NULL);
IZ_ASSERT(num <= MAX_MRT_NUM);
IZ_BOOL ret = IZ_FALSE;
// 現在のレンダーターゲットをプッシュ
for (IZ_UINT i = 0; i < num; ++i) {
CRenderTarget* curRT = GetRenderTarget(i);
if ((rt != IZ_NULL) && (curRT != rt[i]))
{
ret = m_RTMgr[i].Push(curRT);
if (!ret) {
break;
}
}
}
if (ret) {
SetRenderTarget(rt, num);
}
return ret;
}
void Udp::beginRecieve(
std::function<void(const Packet*)> onRecieve,
void* buf,
IZ_UINT size)
{
IZ_ASSERT(onRecieve && buf);
IZ_ASSERT(!m_isRunning);
m_isRunning = IZ_TRUE;
m_recvThread = std::thread(
[this, buf, size, onRecieve]{
while (m_isRunning) {
// TODO
if (wait(0, 1000) > 0) {
Packet packet;
IZ_INT len = recieveFrom(buf, size, packet.endpoint);
if (len > 0) {
packet.data = (IZ_UINT8*)buf;
packet.size = len;
onRecieve(&packet);
}
else {
onRecieve(nullptr);
}
}
sys::CThread::YieldThread();
}
});
}
// 指定されているメッシュに含まれる三角形を取得.
IZ_UINT AssimpImporter::GetTriangles(std::vector<STri>& tvTriList)
{
IZ_ASSERT(m_curMeshIdx < m_scene->mNumMeshes);
auto mesh = m_scene->mMeshes[m_curMeshIdx];
IZ_ASSERT(mesh->HasFaces());
tvTriList.reserve(mesh->mNumFaces);
for (IZ_UINT i = 0; i < mesh->mNumFaces; i++) {
const auto& face = mesh->mFaces[i];
// Check if this is a triangle.
IZ_ASSERT(face.mNumIndices == 3);
// NOTE
// 全頂点を通じた一意のインデックスを指定する.
STri tri;
tri.vtx[0] = face.mIndices[0] + m_VtxPos;
tri.vtx[1] = face.mIndices[1] + m_VtxPos;
tri.vtx[2] = face.mIndices[2] + m_VtxPos;
tvTriList.push_back(tri);
}
// NOTE
// 三角形を構成する頂点に影響を与える（スキニングする）関節インデックスについては外部で処理するので、ここでは何もしない.
m_VtxPos += mesh->mNumVertices;
IZ_UINT ret = mesh->mNumVertices;
return ret;
}
IZ_BOOL CShaderProgramDX9::SetVectorArray(CGraphicsDevice* device, const SHADER_PARAM_HANDLE& handle, const math::SVector4* v, IZ_UINT num)
{
IZ_ASSERT(IsValid());
IZ_ASSERT(device->GetShaderProgram() == this);
_EXEC_ARRAY_FUNC(SetVectorArray, device, v, num);
}
void Node::flush()
{
auto registeredNum = getRegisteredObjNum();
if (registeredNum == 0) {
return;
}
if (!m_fp) {
std::string path(BasePath);
#if 0
auto depth = getDepth();
auto mortonNumber = getMortonNumber();
path += "r";
uint32_t mask = 0x07 << (3 * (depth - 1));
for (uint32_t i = 1; i < depth; i++) {
auto n = mortonNumber & mask;
path += n;
mask >>= 3;
}
path += ".spcd";
fopen_s(&m_fp, path.c_str(), "wb");
IZ_ASSERT(m_fp);
// ヘッダー分空ける.
fseek(m_fp, sizeof(m_header), SEEK_SET);
m_header.magic_number = FOUR_CC('S', 'P', 'C', 'D');
m_header.version = 0;
m_header.depth = depth;
m_header.mortonNumber = mortonNumber;
#else
auto id = getId();
char tmp[10];
sprintf(tmp, "%d\0", id);
path += tmp;
path += ".spcd";
fopen_s(&m_fp, path.c_str(), "wb");
IZ_ASSERT(m_fp);
// ヘッダー分空ける.
fseek(m_fp, sizeof(m_header), SEEK_SET);
m_header.magic_number = FOUR_CC('S', 'P', 'C', 'D');
m_header.version = 0;
#endif
}
// パス記述取得
const S_SHD_PASS* CShaderPassTable::GetDesc(IZ_UINT idx) const
{
IZ_ASSERT(idx < m_Header.numPass);
IZ_ASSERT(m_pDesc != IZ_NULL);
S_SHD_PASS* ret = &m_pDesc[idx];
return ret;
}
void AssimpImporter::GetMaterialTexture(
IZ_UINT nMtrlIdx,
IZ_UINT nTexIdx,
izanagi::S_MTRL_TEXTURE& sTex)
{
IZ_ASSERT(nMtrlIdx < m_scene->mNumMaterials);
const auto mtrl = m_scene->mMaterials[nMtrlIdx];
sTex.type.flags = 0;
IZ_UINT texPos = 0;
for (IZ_UINT i = 0; i < AI_TEXTURE_TYPE_MAX; i++) {
aiTextureType type = (aiTextureType)i;
auto cnt = mtrl->GetTextureCount(type);
if (texPos <= nTexIdx && nTexIdx < texPos + cnt) {
aiString path;
auto idx = nTexIdx - texPos;
mtrl->GetTexture(
type,
idx,
&path);
sTex.name.SetString(path.C_Str());
sTex.key = sTex.name.GetKeyValue();
switch (type) {
case aiTextureType::aiTextureType_DIFFUSE:
// Nothing to do.
break;
case aiTextureType::aiTextureType_NORMALS:
sTex.type.isNormal = IZ_TRUE;
break;
case aiTextureType::aiTextureType_SPECULAR:
sTex.type.isSpecular = IZ_TRUE;
break;
case aiTextureType::aiTextureType_OPACITY:
sTex.type.isTranslucent = IZ_TRUE;
break;
case aiTextureType::aiTextureType_REFLECTION:
sTex.type.isEnvironment = IZ_TRUE;
break;
default:
IZ_ASSERT(IZ_FALSE);
break;
}
break;
}
texPos += cnt;
}
}
// セマフォカウントを解放.
void CSemaphore::Release()
{
// もし、セマフォが非シグナル状態ならセマフォをシグナル状態にする
IZ_ASSERT(m_Handle != IZ_NULL);
IZ_BOOL result = ::ReleaseSemaphore(m_Handle, 1, IZ_NULL);
IZ_ASSERT(result);
}
IZ_UINT CShaderPassTable::GetConstIdx(IZ_UINT passIdx, IZ_UINT constPos) const
{
IZ_ASSERT(passIdx < m_Header.numPass);
IZ_ASSERT(m_pDesc != IZ_NULL);
IZ_ASSERT(m_Holder != IZ_NULL);
IZ_ASSERT(constPos < m_pDesc[passIdx].numConst);
return m_Holder[passIdx].ptrConst[constPos].idx;
}
IZ_UINT CShaderPassTable::GetSmplIdx(IZ_UINT passIdx, IZ_UINT smplPos) const
{
IZ_ASSERT(passIdx < m_Header.numPass);
IZ_ASSERT(m_pDesc != IZ_NULL);
IZ_ASSERT(m_Holder != IZ_NULL);
IZ_ASSERT(smplPos < m_pDesc[passIdx].numSampler);
return m_Holder[passIdx].ptrSampler[smplPos].idx;
}
void CGlyphCacheImpl::BeginRegister()
{
IZ_ASSERT(m_FontMap != IZ_NULL);
IZ_ASSERT(m_FontMapData == IZ_NULL);
m_FontMapPitch = m_FontMap->Lock(
0,
(void**)&m_FontMapData,
IZ_FALSE);
}
IZ_UINT CShaderConstTableLite::GetSamplerIndex(IZ_PCSTR name)
{
IZ_ASSERT(m_ConstTable != IZ_NULL);
D3DXHANDLE handle = m_ConstTable->GetConstantByName(NULL, name);
IZ_ASSERT(handle != IZ_NULL);
IZ_UINT ret = m_ConstTable->GetSamplerIndex(handle);
return ret;
}
IZ_BOOL CColladaAnimation::GetAnmKey(
IZ_UINT nNodeIdx,
IZ_UINT nChannelIdx,
IZ_UINT nKeyIdx,
izanagi::S_ANM_KEY& sKey,
std::vector<IZ_FLOAT>& tvValue)
{
IZ_ASSERT(nNodeIdx < m_AnmNodes.size());
const SAnmNode& sAnmNode = m_AnmNodes[nNodeIdx];
IZ_ASSERT(nChannelIdx < sAnmNode.channels.size());
const SAnmChannel& sAnmChannel = sAnmNode.channels[nChannelIdx];
const SAnmInput* pKeyTime = sAnmChannel.FindInput(E_INPUT_SEMANTIC_INPUT);
VRETURN(pKeyTime != IZ_NULL);
VRETURN(nKeyIdx < pKeyTime->params.size());
const SAnmInput* pValue = sAnmChannel.FindInput(E_INPUT_SEMANTIC_OUTPUT);
VRETURN(pValue != IZ_NULL);
sKey.keyTime = pKeyTime->params[nKeyIdx];
sKey.stride = pValue->stride;
const SAnmInput* pInTanget = sAnmChannel.FindInput(E_INPUT_SEMANTIC_IN_TANGENT);
const SAnmInput* pOutTanget = sAnmChannel.FindInput(E_INPUT_SEMANTIC_OUT_TANGENT);
if ((pInTanget != IZ_NULL) && (pOutTanget != IZ_NULL)) {
VRETURN((sKey.stride == pInTanget->stride)
&& (sKey.stride == pOutTanget->stride));
IZ_UINT pos = sKey.stride * nKeyIdx;
for (IZ_UINT i = 0; i < sKey.stride; i++) {
tvValue.push_back(pValue->params[pos + i]);
tvValue.push_back(pInTanget->params[pos + i]);
tvValue.push_back(pOutTanget->params[pos + i]);
}
}
else {
VRETURN((pInTanget == IZ_NULL)
&& (pOutTanget == IZ_NULL));
tvValue.resize(sKey.stride);
IZ_UINT pos = sKey.stride * nKeyIdx;
for (IZ_UINT i = 0; i < sKey.stride; i++) {
tvValue[i] = pValue->params[pos + i];
}
}
sKey.numParams = static_cast<IZ_UINT>(tvValue.size());
return IZ_TRUE;
}
// セマフォカウントを指定された数だけ増やす.
void CSemaphore::Release(IZ_UINT count/*= 1*/)
{
// もし、セマフォが非シグナル状態ならセマフォをシグナル状態にする
IZ_ASSERT(m_Handle != IZ_NULL);
// ０なんてある？
count = (count == 0 ? 1 : count);
IZ_BOOL result = ::ReleaseSemaphore(m_Handle, count, IZ_NULL);
IZ_ASSERT(result);
}
IZ_BOOL CStateNormalMap::Enter(izanagi::IMemoryAllocator* allocator, void* val)
{
izanagi::graph::CGraphicsDevice* pDevice = CMySystem::GetInstance().GetGraphicsDevice();
izanagi::IMemoryAllocator* pAllocator = CMySystem::GetInstance().GetMemoryAllocator();
// シェーダ
m_pShader = CShaderBase::CreateShader<CNormalMapShader>(
pAllocator,
pDevice,
"./data/NormalMapShader.bin");
//"./data/PhongeShader.bin");
IZ_ASSERT(m_pShader != IZ_NULL);
// グリッド
m_pGrid = izanagi::CDebugMeshGrid::CreateDebugMeshGrid(
pAllocator,
pDevice,
0xffffffff,
20, 20,
10.0f);
IZ_ASSERT(m_pGrid != IZ_NULL);
// XYZ軸
m_pAxis = izanagi::CDebugMeshAxis::CreateDebugMeshAxisDefault(
pAllocator,
pDevice);
IZ_ASSERT(m_pAxis != IZ_NULL);
#if 0
// 球
m_pMesh = izanagi::CDebugMeshSphere::CreateDebugMeshSphere(
pAllocator,
pDevice,
//izanagi::E_DEBUG_MESH_VTX_FORM_POS | izanagi::E_DEBUG_MESH_VTX_FORM_COLOR | izanagi::E_DEBUG_MESH_VTX_FORM_UV | izanagi::E_DEBUG_MESH_VTX_FORM_NORMAL,
izanagi::E_DEBUG_MESH_VTX_FORM_POS | izanagi::E_DEBUG_MESH_VTX_FORM_COLOR | izanagi::E_DEBUG_MESH_VTX_FORM_UV | izanagi::E_DEBUG_MESH_VTX_FORM_NORMAL | izanagi::E_DEBUG_MESH_VTX_FORM_TANGENT,
0xffffffff,
5.0f,
50, 50);
#else
// 矩形
m_pMesh = izanagi::CDebugMeshRectangle::CreateDebugMeshRectangle(
pAllocator,
pDevice,
izanagi::E_DEBUG_MESH_VTX_FORM_POS | izanagi::E_DEBUG_MESH_VTX_FORM_COLOR | izanagi::E_DEBUG_MESH_VTX_FORM_UV | izanagi::E_DEBUG_MESH_VTX_FORM_NORMAL | izanagi::E_DEBUG_MESH_VTX_FORM_TANGENT,
0xffffffff,
1, 1,
20.0f, 20.0f);
#endif
IZ_ASSERT(m_pMesh != IZ_NULL);
return IZ_TRUE;
}
IZ_BOOL CGestureDetector::IsCancel(
threadmodel::CTimerTask* task,
void* data)
{
IZ_ASSERT(task != IZ_NULL);
IZ_ASSERT(data != IZ_NULL);
TYPE type = *(TYPE*)data;
CTask* gestureTask = reinterpret_cast<CTask*>(task);
return (gestureTask->GetGestureType() == type);
}
