// 初期化.
IZ_BOOL CFontRendererApp::InitInternal(
izanagi::IMemoryAllocator* allocator,
izanagi::graph::CGraphicsDevice* device,
izanagi::sample::CSampleCamera& camera)
{
{
izanagi::CFileInputStream in;
VRETURN(in.Open("./data/mikachan..ttf"));
m_Renderer = izanagi::text::CFontRenderer::CreateFontRenderer<izanagi::text::CFontRendererFT>(
allocator,
&in,
32);
VRETURN(m_Renderer != IZ_NULL);
}
{
m_Cache = izanagi::text::CGlyphCacheImpl::CreateGlyphCache(
allocator,
device,
m_Renderer->GetFontHost()->GetEncodeType(),
32,
m_Renderer->GetFontHost()->GetPixelSize(),
IZ_FALSE);
VRETURN(m_Cache != IZ_NULL);
}
return IZ_TRUE;
}
IZ_BOOL CXFileAnimation::Begin(
CXFileParser& cParser,
const std::vector<SXFileNode*>& tvNodeList,
IZ_UINT nAnmSetIdx)
{
const SXFileAnmSet* pAnmSet = cParser.GetAnmSetList()[nAnmSetIdx];
m_AnmNodeList.resize(pAnmSet->anm.size());
for (size_t i = 0; i < m_AnmNodeList.size(); i++) {
SXFileAnm* pAnm = pAnmSet->anm[i];
BreakAnmKeyMtx(pAnm);
SAnmNode& sNode = m_AnmNodeList[i];
{
sNode.nameJoint = pAnm->name;
IZ_INT idx = _GetNodeIdxByName(tvNodeList, sNode.nameJoint);
#if 0
VRETURN(idx >= 0);
#else
if (idx < 0) {
continue;
}
#endif
sNode.idxJoint = idx;
VRETURN(SetAnmChannels(pAnm, sNode));
}
}
return IZ_TRUE;
}
/**
* 初期化
*/
IZ_BOOL CPadDInput::Init(
SInputDeviceInitParam* initParam,
IZ_FLOAT analogStickDeadZone)
{
SInputDeviceInitParam* param = reinterpret_cast<SInputDeviceInitParam*>(initParam);
D_INPUT* input = IZ_NULL;
VRETURN(InitDirectInput(*param, &input));
HWND hWnd = (HWND)param->nativeWindowHandle;
m_InputTmp = input;
HRESULT hr;
// 利用可能なパッドの列挙関数を実行
hr = m_InputTmp->EnumDevices(
DI8DEVCLASS_GAMECTRL,
EnumGameCtrlCallback,
this,
DIEDFL_ATTACHEDONLY);
VRETURN(SUCCEEDED(hr));
m_pPadDevice = m_DevTmp;
if (m_pPadDevice == IZ_NULL)
{
return IZ_FALSE;
}
// デバイスをパッドに設定
// デフォルトの設定を使用
#if 0
hr = m_pPadDevice->SetDataFormat(&c_dfDIJoystick2);
#else
hr = m_pPadDevice->SetDataFormat(&c_dfDIJoystick);
#endif
VRETURN(SUCCEEDED(hr));
// 協調レベルの設定
hr = m_pPadDevice->SetCooperativeLevel(
hWnd,
DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
VRETURN(SUCCEEDED(hr));
// パッドのプロパティを列挙して設定
// アナログスティック設定
hr = m_pPadDevice->EnumObjects(
EnumPadAxisCallback,
//(void*)pInitParam->hWnd,
this,
DIDFT_AXIS);
VRETURN(SUCCEEDED(hr));
// 一応・・・
m_hWnd = hWnd;
return IZ_TRUE;
}
bool FoveatedRenderingApp::Shader::Init(
izanagi::graph::CGraphicsDevice* device,
const char* pathVs, const char* pathPs)
{
// シェーダ
{
izanagi::CFileInputStream in;
VRETURN(in.Open(pathVs));
std::vector<uint8_t> buf(in.GetSize() + 1);
in.Read(&buf[0], 0, in.GetSize());
m_vs = device->CreateVertexShader(&buf[0]);
VRETURN(m_vs != IZ_NULL);
}
{
izanagi::CFileInputStream in;
VRETURN(in.Open(pathPs));
std::vector<uint8_t> buf(in.GetSize() + 1);
in.Read(&buf[0], 0, in.GetSize());
m_fs = device->CreatePixelShader(&buf[0]);
VRETURN(m_fs != IZ_NULL);
}
{
m_shd = device->CreateShaderProgram();
m_shd->AttachVertexShader(m_vs);
m_shd->AttachPixelShader(m_fs);
}
return true;
}
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 CColladaAnimation::GetInterpType(
domInputLocalRef pInput,
SAnmChannel& sAnmChannel)
{
domSource* pSrc = (domSource*)((domElement*)pInput->getSource().getElement());
VRETURN(pSrc != IZ_NULL);
domUint num = pSrc->getName_array()->getCount();
izanagi::E_ANM_INTERP_TYPE nInterp = izanagi::E_ANM_INTERP_TYPE_NUM;
for (domUint i = 0; i < num; i++) {
daeString name = pSrc->getName_array()->getValue().get((size_t)i);
if (izanagi::tool::CString::CmpStr(name, "BEZIER")) {
// NOTE
// I think collada bezier parameters are for hermite not bezier...
nInterp = izanagi::E_ANM_INTERP_TYPE_HERMITE;
}
else {
// TODO
VRETURN(IZ_FALSE);
}
if (i > 0) {
// Interpolation must be same.
VRETURN(sAnmChannel.interp == nInterp);
}
sAnmChannel.interp = nInterp;
}
return IZ_TRUE;
}
IZ_BOOL CXFileAnimation::GetAnmKey(
IZ_UINT nNodeIdx,
IZ_UINT nChannelIdx,
IZ_UINT nKeyIdx,
izanagi::S_ANM_KEY& sKey,
std::vector<IZ_FLOAT>& tvValue)
{
VRETURN(nNodeIdx < GetAnmNodeNum());
const SAnmNode& sAnmNode = m_AnmNodeList[nNodeIdx];
VRETURN(nChannelIdx < sAnmNode.channels.size());
const SAnmChannel& sAnmChannel = sAnmNode.channels[nChannelIdx];
VRETURN(nKeyIdx < sAnmChannel.keys.size());
const SAnmKey& sAnmKey = sAnmChannel.keys[nKeyIdx];
sKey.keyTime = static_cast<IZ_FLOAT>(sAnmKey.time);
switch (sAnmChannel.type) {
case izanagi::E_ANM_TRANSFORM_TYPE_QUATERNION:
sKey.numParams = 4;
sKey.stride = 4;
break;
case izanagi::E_ANM_TRANSFORM_TYPE_SCALE:
sKey.numParams = 3;
sKey.stride = 3;
break;
case izanagi::E_ANM_TRANSFORM_TYPE_TRANSLATE:
sKey.numParams = 3;
sKey.stride = 3;
break;
default:
VRETURN(IZ_FALSE);
break;
}
tvValue.resize(sKey.numParams);
switch (sAnmChannel.type) {
case izanagi::E_ANM_TRANSFORM_TYPE_QUATERNION:
tvValue[0] = sAnmKey.param.x;
tvValue[1] = sAnmKey.param.y;
tvValue[2] = sAnmKey.param.z;
tvValue[3] = sAnmKey.param.w;
break;
case izanagi::E_ANM_TRANSFORM_TYPE_SCALE:
case izanagi::E_ANM_TRANSFORM_TYPE_TRANSLATE:
tvValue[0] = sAnmKey.param.x;
tvValue[1] = sAnmKey.param.y;
tvValue[2] = sAnmKey.param.z;
break;
}
return IZ_TRUE;
}
IZ_BOOL UnityChanApp::CreateMaterial(izanagi::IMemoryAllocator* allocator)
{
static const char* mtrls[] = {
"data/unitychan_0.mtrl",
"data/unitychan_1.mtrl",
"data/unitychan_2.mtrl",
"data/unitychan_3.mtrl",
"data/unitychan_4.mtrl",
"data/unitychan_5.mtrl",
"data/unitychan_6.mtrl",
"data/unitychan_7.mtrl",
"data/unitychan_8.mtrl",
};
static const IZ_UINT IMG_IDX = 0;
izanagi::CFileInputStream in;
IZ_ASSERT(COUNTOF(mtrls) <= COUNTOF(m_Mtrl));
for (IZ_UINT i = 0; i < COUNTOF(mtrls); i++) {
VRETURN(in.Open(mtrls[i]));
m_Mtrl[i] = izanagi::CMaterial::CreateMaterial(allocator, &in);
VRETURN(m_Mtrl[i] != IZ_NULL);
in.Finalize();
}
static const char* mtrlTexName[] = {
"face_00.tga",
"eyeline_00.tga",
"eye_iris_L_00.tga",
"eye_iris_R_00.tga",
"body_01.tga",
"eyeline_00.tga",
"hair_01.tga",
"skin_01.tga",
"cheek_00.tga",
};
// 基本的には事前にマテリアル名とシェーダ名を一致させておくべきだが
// シェーダ名を強制的に変更することもできる
// シェーダ名を見てマテリアルをバインディングする
m_Shd->SetName("Phong");
for (IZ_UINT i = 0; i < COUNTOF(m_Mtrl); i++) {
// マテリアルに対応するテクスチャとシェーダを設定
m_Mtrl[i]->SetTexture(mtrlTexName[i], m_Img->GetTexture(i));
m_Mtrl[i]->SetShader(m_Shd);
// メッシュにマテリアルを設定
m_Mdl->GetMesh()->SetMaterial(0, m_Mtrl[i]);
}
return IZ_TRUE;
}
IZ_BOOL CXFileImporter::ReadBaseModel(IZ_PCSTR pszName)
{
VRETURN(m_BaseMdlParser == IZ_NULL);
m_BaseMdlParser = new CXFileParser;
VRETURN(m_BaseMdlParser->Parse(pszName));
return IZ_TRUE;
}
/**
* シェーダ解析
*/
BOOL CShaderConverter::Export(const SShaderConfig& sConfig)
{
IZ_ASSERT(m_pCgEffect != NULL);
VRETURN(m_Out.Open(sConfig.out));
// ファイルヘッダ
{
FILL_ZERO(&m_ShdHeader, sizeof(m_ShdHeader));
// TODO
// magic
// version
m_ShdHeader.name.SetString(sConfig.name);
m_ShdHeader.nameKey = m_ShdHeader.name.GetKeyValue();
m_ShdHeader.sizeHeader = sizeof(m_ShdHeader);
}
// ファイルヘッダ分空ける
VRETURN(m_Out.Seek(sizeof(m_ShdHeader), izanagi::E_IO_STREAM_SEEK_POS_START));
ExportParameter(sConfig);
ExportTexture();
ExportSampler(sConfig);
ExportTechnique();
ExportPass(sConfig);
ExportStringBuffer();
// Export program chunk's header.
_ExportChunkHeader(m_Out, izanagi::shader::SHD_CHUNK_MAGIC_NUMBER_PROG);
// プログラム開始位置
m_ShdHeader.posProgram = m_Out.GetCurPos();
ExportProgram(sConfig);
// Export chunk's terminater.
//_ExportChunkHeader(m_Out, izanagi::SHD_PROGRAM_CHUNK_TERMINATER);
// ファイルサイズ取得
m_ShdHeader.sizeFile = m_Out.GetCurPos();
// 先頭に戻る
VRETURN(m_Out.Seek(0, izanagi::E_IO_STREAM_SEEK_POS_START));
// ファイルヘッダ出力
m_Out.Write(&m_ShdHeader, 0, sizeof(m_ShdHeader));
m_Out.Finalize();
return TRUE;
}
/**
* テクニック解析
*/
BOOL CShaderConverter::ExportTechnique()
{
VRETURN(_ExportChunkHeader(m_Out, izanagi::shader::SHD_CHUNK_MAGIC_NUMBER_TECH));
izanagi::shader::S_SHD_TECH_HEADER sTechHeader;
FILL_ZERO(&sTechHeader, sizeof(sTechHeader));
// Blank for technique's header.
izanagi::tool::CIoStreamSeekHelper cSeekHelper(&m_Out);
VRETURN(_BeginExportChunk(sTechHeader, cSeekHelper));
UINT nPassPos = 0;
// テクニック取得
CGtechnique tech = ::cgGetFirstTechnique(m_pCgEffect);
if (tech != NULL) {
while (tech != NULL) {
izanagi::shader::S_SHD_TECHNIQUE sTech;
{
FILL_ZERO(&sTech, sizeof(sTech));
IZ_PCSTR name = ::cgGetTechniqueName(tech);
IZ_UINT pos = CStringChunk::GetInstance().Register(name);
//sTech.name = *(IZ_PCSTR*)(&pos);
sTech.posName = pos;
sTech.keyName = izanagi::CKey::GenerateValue(name);
sTech.numPass = _GetPassNum(tech);
sTech.posPass = nPassPos;
}
nPassPos += sTech.numPass;
// 出力
VRETURN(ExportData(sTech));
tech = ::cgGetNextTechnique(tech);
sTechHeader.numTechnique++;
}
}
else {
// テクニックは必ず一つはないといけない
IZ_ASSERT(FALSE);
// TODO
return FALSE;
}
VRETURN(_EndExportChunk(sTechHeader, cSeekHelper));
return TRUE;
}
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;
}
BOOL CShaderConverter::ExportTexture()
{
VRETURN(_ExportChunkHeader(m_Out, izanagi::shader::SHD_CHUNK_MAGIC_NUMBER_TEX));
izanagi::shader::S_SHD_TEXTRUE_HEADER sTexHeader;
FILL_ZERO(&sTexHeader, sizeof(sTexHeader));
// Blank for texture's header.
izanagi::tool::CIoStreamSeekHelper cSeekHelper(&m_Out);
VRETURN(_BeginExportChunk(sTexHeader, cSeekHelper));
m_TexList.clear();
CGparameter param = ::cgGetFirstEffectParameter(m_pCgEffect);
while (param != NULL) {
if (CParamUtil::IsTexture(param)) {
izanagi::shader::S_SHD_TEXTURE sTex;
{
FILL_ZERO(&sTex, sizeof(sTex));
CParamUtil::SetNameAndSemantic(sTex, param);
#if 0
sTex.type = _GetTexTypeFromSemantic(param);
sTex.ann.isRenderTarget = IZ_TRUE;
sTex.ann.isDynamic = IZ_FALSE;
sTex.ann.typeRsc = izanagi::graph::E_GRAPH_RSC_USAGE_STATIC;
VRETURN(
CTextureUtil::SetAnnValue(
sTex.ann,
param));
#endif
}
m_TexList.push_back(param);
// 出力
VRETURN(ExportData(sTex));
sTexHeader.numTexture++;
}
param = ::cgGetNextParameter(param);
}
VRETURN(_EndExportChunk(sTexHeader, cSeekHelper));
m_ShdHeader.numTexture = sTexHeader.numTexture;
return TRUE;
}
IZ_BOOL CColladaAnimation::ReadJoint(domNodeRef pNode)
{
domNodeType type = pNode->getType();
if (type == NODETYPE_JOINT) {
SJoint sJoint;
sJoint.name = pNode->getName();
for (size_t n = 0; n < pNode->getContents().getCount(); n++) {
domElement* pContent = pNode->getContents().get(n);
daeString strType = pContent->getTypeName();
if (izanagi::tool::CString::CmpStr(strType, "node")) {
// terminate...
continue;
}
SJointTransform sTransform;
sTransform.type = GetTransformType(strType);
switch (sTransform.type) {
case E_TRANSFROM_TYPE_TRANSLATE:
GetTransform<domTranslate, 3>(pContent, sTransform);
break;
case E_TRANSFROM_TYPE_QUARTANION:
GetTransform<domRotate, 4>(pContent, sTransform);
break;
case E_TRANSFROM_TYPE_SCALE:
GetTransform<domScale, 3>(pContent, sTransform);
break;
default:
VRETURN(IZ_FALSE);
break;
}
sJoint.transforms.push_back(sTransform);
}
if (!sJoint.transforms.empty()) {
m_Joints.push_back(sJoint);
}
}
size_t nChildNodeCnt = pNode->getNode_array().getCount();
for (size_t n = 0; n < nChildNodeCnt; n++) {
domNodeRef node = pNode->getNode_array().get(n);
VRETURN(ReadJoint(node));
}
return IZ_TRUE;
}
IZ_BOOL CXFileImporter::BeginAnm(IZ_UINT nSetIdx)
{
VRETURN(nSetIdx < GetAnmSetNum());
VRETURN(m_BaseMdlParser != IZ_NULL);
IZ_BOOL ret = CXFileAnimation::GetInstance().Begin(
m_Parser,
m_BaseMdlParser->GetNodeList(),
nSetIdx);
return ret;
}
IZ_BOOL CColladaAnimation::GetAnmInputParams(
domInputLocalRef pInput,
const SAnmChannel& sAnmChannel,
SAnmInput& sAnmInput)
{
domSource* pSrc = (domSource*)((domElement*)pInput->getSource().getElement());
VRETURN(pSrc != IZ_NULL);
if (sAnmInput.semantic == E_INPUT_SEMANTIC_INPUT) {
// Stride must be 1.
sAnmInput.stride = (IZ_UINT)pSrc->getTechnique_common()->getAccessor()->getStride();
VRETURN(sAnmInput.stride == 1);
// Input parmeter means "TIME".
domUint nParamCnt = pSrc->getTechnique_common()->getAccessor()->getParam_array().getCount();
VRETURN(nParamCnt == 1);
domParamRef pParam = pSrc->getTechnique_common()->getAccessor()->getParam_array().get(0);
daeString name = pParam->getName();
VRETURN(izanagi::tool::CString::CmpStr(name, "TIME"));
domUint num = pSrc->getFloat_array()->getCount();
for (size_t i = 0; i < num; i++) {
IZ_FLOAT time = (IZ_FLOAT)pSrc->getFloat_array()->getValue().get(i);
sAnmInput.params.push_back(time);
}
}
else if ((sAnmInput.semantic == E_INPUT_SEMANTIC_OUTPUT)
|| (sAnmInput.semantic == E_INPUT_SEMANTIC_IN_TANGENT)
|| (sAnmInput.semantic == E_INPUT_SEMANTIC_OUT_TANGENT))
{
domUint nStride = pSrc->getTechnique_common()->getAccessor()->getStride();
// TODO
// Check paramater stride size is valid.
// ex) translate -> 3 / rotate -> 1 / scale -> 3 etc...
IZ_ASSERT(_GetStride(sAnmChannel.type) == nStride);
IZ_UINT num = static_cast<IZ_UINT>(pSrc->getFloat_array()->getCount());
for (IZ_UINT i = 0; i < num; i++) {
IZ_FLOAT val = (IZ_FLOAT)pSrc->getFloat_array()->getValue().get(i);
sAnmInput.params.push_back(val);
}
sAnmInput.stride = (IZ_UINT)nStride;
}
return IZ_TRUE;
}
BOOL CParamUtil::GetInitValue(
izanagi::shader::S_SHD_PARAMETER& sDesc,
CGparameter param)
{
IZ_UINT nElements = sDesc.Rows * sDesc.Columns;
nElements = (sDesc.Elements > 0 ? nElements * sDesc.Elements : nElements);
IZ_UINT nParamSize = sDesc.Bytes;
CGtype type = _GetCGType(param);
int nValueNum = 0;
std::vector<IZ_UINT8> tvBuf(nParamSize);
if (CShaderConvUtil::IsIntType(type)) {
// int
nValueNum = cgGetParameterValueir(
param,
nElements,
(int*)&tvBuf[0]);
}
else if (CShaderConvUtil::IsFloatType(type)) {
// float
nValueNum = cgGetParameterValuefr(
param,
nElements,
(float*)&tvBuf[0]);
#if 0
for (int i = 0; i < nValueNum; i++) {
float xx = *(float*)&tvBuf[i * 4];
printf("%f\n", xx);
}
#endif
}
else {
VRETURN(IZ_FALSE);
}
BOOL ret = (nValueNum > 0);
VRETURN(ret);
if (ret) {
sDesc.hasDefaultValue = IZ_TRUE;
sDesc.Pos = CDataBuffer::GetInstance().Register(
&tvBuf[0],
tvBuf.size());
}
return ret;
}
BOOL CShaderConverter::ExportProgram(const SShaderConfig& config)
{
VRETURN(m_CompiledPSList.size() == m_CompiledVSList.size());
for (size_t i = 0; i < m_CompiledVSList.size(); i++) {
const izanagi::tool::CString strVS = m_CompiledVSList[i];
const izanagi::tool::CString strPS = m_CompiledPSList[i];
VRETURN(_ExportFile(config, strVS, &m_Out));
VRETURN(_ExportFile(config, strPS, &m_Out));
}
return TRUE;
}
/**
* シェーダ解析
*/
BOOL CPostEffectConverter::Export(LPCSTR lpszOutFile)
{
IZ_ASSERT(m_pCgEffect != NULL);
VRETURN(m_Out.Open(lpszOutFile));
// ファイルヘッダ
{
FILL_ZERO(&m_PesHeader, sizeof(m_PesHeader));
// TODO
// magic
// version
m_PesHeader.sizeHeadaer = sizeof(m_PesHeader);
}
// ファイルヘッダ分空ける
VRETURN(m_Out.Seek(sizeof(m_PesHeader), izanagi::E_IO_STREAM_SEEK_POS_START));
ExportParameter();
ExportTexture();
ExportSampler();
ExportTechnique();
ExportPass();
ExportUsedParamAndSamplerIdxByPass();
ExportStringBuffer();
// プログラム位置
m_PesHeader.posProgram = m_Out.GetCurPos();
ExportPSProgram();
ExportVSProgram();
// ファイルサイズ取得
m_PesHeader.sizeFile = m_Out.GetCurPos();
// 先頭に戻る
VRETURN(m_Out.Seek(0, izanagi::E_IO_STREAM_SEEK_POS_START));
// ファイルヘッダ出力
m_Out.Write(&m_PesHeader, 0, sizeof(m_PesHeader));
m_Out.Finalize();
return TRUE;
}
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;
}
BOOL CPostEffectConverter::ExportUsedParamAndSamplerIdxByPass(CGpass pass)
{
VRETURN(
_ExportUsedParamIdxByPass(
&m_Out,
m_ParamList,
pass));
VRETURN(
_ExportUsedParamIdxByPass(
&m_Out,
m_SamplerList,
pass));
return TRUE;
}
IZ_BOOL CXFileAnimation::BreakAnmKeyMtx(SXFileAnm* pAnm)
{
for (size_t i = 0; i < pAnm->keys.size(); i++) {
SXFileAnmKey& sAnmKey = pAnm->keys[i];
if (!sAnmKey.type.mtx) {
// This key has not matrix.
continue;
}
izanagi::S_SKL_JOINT_POSE sPoseTmp;
IZ_BOOL bHasScale = CXFileMathUtil::BreakDownMatrix(
sAnmKey.data.mtx,
sPoseTmp);
VRETURN(!bHasScale);
memcpy(&sAnmKey.data.pose, &sPoseTmp, sizeof(izanagi::S_SKL_JOINT_POSE));
sAnmKey.type.mtx = IZ_FALSE;
// TODO
sAnmKey.type.quat = IZ_TRUE;
sAnmKey.type.scale = IZ_TRUE;
sAnmKey.type.trans = IZ_TRUE;
}
return IZ_TRUE;
}
BOOL CSamplerUtil::BindTexture(
izanagi::shader::S_SHD_SAMPLER& sDesc,
CGparameter param,
std::vector<CGparameter>& tvTexList)
{
CGstateassignment sa = ::cgGetFirstSamplerStateAssignment(param);
while (sa != NULL) {
CGstate state = cgGetSamplerStateAssignmentState(sa);
izanagi::tool::CString str(::cgGetStateName(state));
if (str == "Texture") {
CGparameter tex = ::cgGetTextureStateAssignmentValue(sa);
std::vector<CGparameter>::iterator it = std::find(
tvTexList.begin(),
tvTexList.end(),
tex);
VRETURN(it != tvTexList.end());
// サンプラにバインドするテクスチャのインデックス
sDesc.BindTexIdx = static_cast<IZ_INT>(std::distance(tvTexList.begin(), it));
break;
}
sa = ::cgGetNextStateAssignment(sa);
}
return TRUE;
}
// 指定ディレクトリの情報を登録する
BOOL CFileTree::RegisterFileTree(LPCSTR lpszPath)
{
izanagi::tool::CString strDir(PathFindFileName(lpszPath));
// 末尾の'/'を消す
{
size_t nStrLen = strlen(strDir);
int nDelimiterPos_0 = strDir.reverse_find(DELIMITER_0);
int nDelimiterPos_1 = strDir.reverse_find(DELIMITER_1);
if ((nStrLen == nDelimiterPos_0)
|| (nStrLen == nDelimiterPos_1))
{
LPCSTR str = strDir;
const_cast<CHAR*>(str)[nStrLen] = '\0';
}
}
// 自分自身をチェック
{
WIN32_FIND_DATA dataFile;
HANDLE hIter = FindFirstFile(strDir, &dataFile);
VRETURN(hIter != NULL);
VRETURN(dataFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
}
// TODO
m_FileList.reserve(100);
// TODO
m_TmpDirList.reserve(10);
m_TmpDirList.push_back(strDir);
while (m_TmpDirList.size() > 0) {
std::vector<izanagi::tool::CString>::iterator it = m_TmpDirList.begin();
IZ_ASSERT(it != m_TmpDirList.end());
const izanagi::tool::CString& strDir = *it;
RegisterFileTreeInternal(strDir);
m_TmpDirList.erase(it);
}
return TRUE;
}
BOOL CShaderConverter::ExportUsedParamAndSamplerIdxByPass(CGpass pass)
{
// 指定されたパス内で利用されているパラメータのインデックスを出力
VRETURN(
_ExportUsedParamIdxByPass(
&m_Out,
m_ParamList,
pass));
// / 指定されたパス内で利用されているサンプラのインデックスを出力
VRETURN(
_ExportUsedParamIdxByPass(
&m_Out,
m_SamplerList,
pass));
return TRUE;
}
// グラフィックスデバイス初期化
tool::CGraphicsDeviceLite* InitGraphicsDevice(void* hWnd)
{
// GraphcsDevice作成
if (s_Device == IZ_NULL) {
s_Device = izanagi::tool::CGraphicsDeviceLite::CreateGraphicsDeviceLight((HWND)hWnd);
VRETURN(s_Device != IZ_NULL);
}
return s_Device;
}
// ロック
IZ_BOOL CVertexBufferGLES2::Lock(
CGraphicsDevice* device,
IZ_UINT offset,
IZ_UINT size,
void** data,
IZ_BOOL isReadOnly,
IZ_BOOL isDiscard/*= IZ_FALSE*/)
{
// NOTE
// isReadOnly, isDiscard は無効
VRETURN(size + offset <= m_Size);
IZ_ASSERT(m_VB > 0);
size = (size == 0 ? m_Size : size);
if (m_TemporaryData == IZ_NULL) {
m_TemporaryData = ALLOC(m_Allocator, size);
m_AllocSize = size;
}
else if (size > m_AllocSize) {
m_TemporaryData = REALLOC(m_Allocator, m_TemporaryData, size);
m_AllocSize = size;
}
VRETURN(m_TemporaryData != IZ_NULL);
IZ_UINT8* tmp = reinterpret_cast<IZ_UINT8*>(m_TemporaryData);
tmp += offset;
*data = tmp;
m_LockOffset = offset;
m_LockSize = size;
if (m_LockOffset > 0
&& m_LockSize + m_LockOffset > m_Size)
{
m_LockSize = m_Size - m_LockOffset;
}
return IZ_TRUE;
}
IZ_BOOL CColladaAnimation::ReadJoint(domVisual_scene* pScene)
{
size_t nNodeCnt = pScene->getNode_array().getCount();
for (size_t i = 0; i < nNodeCnt; i++) {
domNodeRef pNode = pScene->getNode_array().get(i);
VRETURN(ReadJoint(pNode));
}
return IZ_TRUE;
}
// シェーダセット
IZ_BOOL C2DShader::SetShader(CGraphicsDevice* device)
{
IZ_ASSERT(device != IZ_NULL);
IZ_ASSERT(m_pPS[m_nOp] != IZ_NULL);
if (m_nOp == E_GRAPH_2D_RENDER_OP_USER_DEFS
&& m_UserDefsVS != IZ_NULL)
{
VRETURN(m_ShaderProgram[m_nOp]->AttachVertexShader(m_UserDefsVS));
}
else {
VRETURN(m_ShaderProgram[m_nOp]->AttachVertexShader(m_pVS));
}
VRETURN(m_ShaderProgram[m_nOp]->AttachPixelShader(m_pPS[m_nOp]));
VRETURN(device->SetShaderProgram(m_ShaderProgram[m_nOp]));
return IZ_TRUE;
}
IZ_BOOL CXFileAnimation::GetAnmChannel(
IZ_UINT nNodeIdx,
IZ_UINT nChannelIdx,
izanagi::S_ANM_CHANNEL& sChannel)
{
VRETURN(nNodeIdx < GetAnmNodeNum());
const SAnmNode& sAnmNode = m_AnmNodeList[nNodeIdx];
VRETURN(nChannelIdx < sAnmNode.channels.size());
const SAnmChannel& sAnmChannel = sAnmNode.channels[nChannelIdx];
sChannel.interp = sAnmChannel.interp;
sChannel.numKeys = static_cast<IZ_UINT16>(sAnmChannel.keys.size());
switch (sAnmChannel.type) {
case izanagi::E_ANM_TRANSFORM_TYPE_QUATERNION:
sChannel.stride = 4;
break;
case izanagi::E_ANM_TRANSFORM_TYPE_SCALE:
sChannel.stride = 3;
break;
case izanagi::E_ANM_TRANSFORM_TYPE_TRANSLATE:
sChannel.stride = 3;
break;
default:
VRETURN(IZ_FALSE);
break;
}
sChannel.type = sAnmChannel.type;
if (sChannel.type & izanagi::E_ANM_TRANSFORM_TYPE_QUATERNION) {
sChannel.type |= izanagi::E_ANM_TRANSFORM_TYPE_XYZW;
}
else {
sChannel.type |= izanagi::E_ANM_TRANSFORM_TYPE_XYZ;
}
return IZ_TRUE;
}
