void CKLBOGLWrapper::releaseShader(CShader* pShader) {
CShader* p = this->shaderList;
CShader* prev = null;
while (p != pShader) {
prev = p;
p = p->pNext;
}
//
// Remove from link list.
//
if (prev == null) {
this->shaderList = pShader->pNext;
} else {
prev->pNext = pShader->pNext;
}
//
// Delete shader from GL
//
dglDeleteShader(pShader->shaderObj);
// Free param
if (pShader->arrayParam) {
KLBDELETE(pShader->arrayParam);
}
// Delete object
KLBDELETE(pShader);
}
void JSonDB::clean() {
RecordListHeader* pRecord = m_startRecord;
while (pRecord) {
RecordListHeader* pNextRecord = pRecord->pNextRecord;
KLBDELETE(pRecord->fields);
KLBDELETE(pRecord);
pRecord = pNextRecord;
}
m_startRecord = NULL;
KLBDELETEA(mStringRecordBuffer);
mStringRecordBuffer = NULL;
}
void
CKLBUpdate::exec_unzip(u32 /*deltaT*/)
{
bool bResult = true;
if(m_extracting) {
if(m_unzip->isFinishExtract()) {
// 戻り値が true であれば読み込みが終わっている
m_extracting = false;
bResult = m_unzip->gotoNextFile(); // 次のファイルへ
// 現在展開済みのファイル数を得る
int finished = m_unzip->getFinishedEntry();
CKLBScriptEnv::getInstance().call_eventUpdateZIP(m_callbackZIP, this, finished, m_zipEntry);
if(!bResult) {
// 展開終了
KLBDELETE(m_unzip);
m_unzip = NULL;
// テンポラリzip削除
CPFInterface::getInstance().platform().removeTmpFile(m_tmpPath);
m_eStep = S_COMPLETE;
}
}
}
// 次のファイルがあり、なおかつ展開処理が終了していれば次のファイルの読み込みを開始する
if(bResult && !m_extracting) {
if(m_unzip->readCurrentFileInfo()) {
m_unzip->extractCurrentFile("file://external/");
m_extracting = true;
}
}
}
/*static*/
IDataSource* JSonDB::openDB(const u8* source, u32 sourceLength) {
JSonDB* newDB = KLBNEW(JSonDB);
if (!newDB->readDBInternal(source, sourceLength)) {
KLBDELETE(newDB);
newDB = NULL;
}
return newDB;
}
CKLBUIButton* CKLBUIButton::create(CKLBTask* pParentTask, const char * funcName) {
CKLBUIButton* pTask = KLBNEW(CKLBUIButton);
if(!pTask) return 0;
if(!pTask->init(pParentTask, funcName)) {
KLBDELETE(pTask);
return 0;
}
return pTask;
}
/*virtual*/
CKLBAbstractAsset* KLBAudioAssetPlugin::loadByFileName(const char* url) {
CKLBAudioAsset* pAudioAsset = KLBNEW(CKLBAudioAsset);
if (pAudioAsset) {
if (pAudioAsset->init(url)) {
return pAudioAsset;
}
KLBDELETE(pAudioAsset);
}
return NULL;
}
CKLBPauseCtrl*
CKLBPauseCtrl::create(CKLBTask* pParentTask, const char* pause, const char* resume) {
CKLBPauseCtrl* pTask = KLBNEW(CKLBPauseCtrl);
if(!pTask) { return NULL; }
if(!pTask->init(pParentTask, pause,resume)) {
KLBDELETE(pTask);
return NULL;
}
return pTask;
}
CKLBLifeCtrlTask*
CKLBLifeCtrlTask::create(CKLBTask* pParentTask, u32 mode, u32 limit) {
CKLBLifeCtrlTask* pTask = KLBNEW(CKLBLifeCtrlTask);
if(!pTask) { return NULL; }
if(!pTask->init(pParentTask, mode, limit)) {
KLBDELETE(pTask);
return NULL;
}
return pTask;
}
CKLBUISimpleItem*
CKLBUISimpleItem::create(CKLBUITask* pParent, CKLBNode* pNode, u32 order, float x, float y, const char* asset)
{
CKLBUISimpleItem* pTask = KLBNEW(CKLBUISimpleItem);
if(!pTask) { return NULL; }
if(!pTask->init(pParent, pNode, order,x,y,asset)) {
KLBDELETE(pTask);
return NULL;
}
return pTask;
}
CKLBUIControl*
CKLBUIControl::create(CKLBTask* pParentTask, const char* onClick, const char* onDrag) {
CKLBUIControl* pTask = KLBNEW(CKLBUIControl);
if(!pTask) { return NULL; }
if(!pTask->init(pParentTask, onClick, onDrag)) {
KLBDELETE(pTask);
return NULL;
}
return pTask;
}
CKLBUIMultiImgItem*
CKLBUIMultiImgItem::create(CKLBUITask* pParent, CKLBNode* pNode, u32 order, float x, float y, u32 idx, const char** pArrayAsset, u32* pArrayIndexes, u32 assetCount)
{
CKLBUIMultiImgItem* pTask = KLBNEW(CKLBUIMultiImgItem);
if(!pTask) { return NULL; }
if(!pTask->init(pParent, pNode, order, x,y,idx,pArrayAsset, pArrayIndexes, assetCount)) {
KLBDELETE(pTask);
return NULL;
}
return pTask;
}
CKLBUITouchPad*
CKLBUITouchPad::create(CKLBTask* pParentTask, const char * funcName, bool modal)
{
CKLBUITouchPad* pTask = KLBNEW(CKLBUITouchPad);
if(!pTask) { return NULL; }
if(!pTask->init(pParentTask, funcName, modal)) {
KLBDELETE(pTask);
return NULL;
}
return pTask;
}
void CKLBOGLWrapper::releaseShaderSet(CShaderSet* pFullShader) {
klb_assertc(pFullShader, "null shader set");
CShaderSet* p = this->shaderSetList;
CShaderSet* pPrev = null;
while (p != pFullShader) {
pPrev = p;
p = p->pNext;
}
if (pPrev == null) {
this->shaderSetList = p->pNext;
} else {
pPrev->pNext = p->pNext;
}
// Release all instances.
pFullShader->releaseAllInstances();
// Release open GL associated program.
dglDeleteProgram(pFullShader->programObj);
if (pFullShader->locationArray) {
KLBDELETE(pFullShader->locationArray);
}
pFullShader->vertexShader->refCount--;
pFullShader->pixelShader->refCount--;
if (pFullShader->vertexShader->refCount == 0) {
this->releaseShader(pFullShader->vertexShader);
}
if (pFullShader->pixelShader->refCount == 0) {
this->releaseShader(pFullShader->pixelShader);
}
KLBDELETE(pFullShader);
}
CKLBGenericTask*
CKLBGenericTask::create(CKLBTask* pParentTask, CKLBTask::TASK_PHASE phase, const char * name_exec, const char * name_die, const char * arr_index)
{
CKLBGenericTask* pTask = KLBNEW(CKLBGenericTask);
if(!pTask) {
return NULL;
}
if(!pTask->init(pParentTask, phase, name_exec, name_die, arr_index)) {
KLBDELETE(pTask);
return NULL;
}
return pTask;
}
CKLBUIScore *
CKLBUIScore::create(CKLBUITask * pParent, CKLBNode * pNode,
u32 order, s32 order_offset, float x, float y,
const char ** tex_table, float stepX, float stepY, int column,
bool fillzero, bool anim_flags, u32 align, bool countclip)
{
CKLBUIScore * pTask = KLBNEW(CKLBUIScore);
if(!pTask) { return NULL; }
if(!pTask->init(pParent, pNode, order, order_offset, x, y, tex_table, stepX, stepY, column, fillzero, anim_flags, align, countclip)) {
KLBDELETE(pTask);
return NULL;
}
return pTask;
}
void
CKLBLuaLibFONT::remove_font(FONTOBJ * fontobj)
{
IPlatformRequest& pForm = CPFInterface::getInstance().platform();
pForm.deleteFont(fontobj->font);
if(fontobj->prev) {
fontobj->prev->next = fontobj->next;
} else {
ms_begin = fontobj->next;
}
if(fontobj->next) {
fontobj->next->prev = fontobj->prev;
} else {
ms_end = fontobj->prev;
}
KLBDELETE(fontobj);
}
void
CKLBUpdate::die()
{
if (m_thread) {
CPFInterface::getInstance().platform().deleteThread(m_thread);
m_thread = NULL;
}
KLBDELETEA(m_zipURL);
KLBDELETEA(m_tmpPath);
KLBDELETEA(m_callbackZIP);
KLBDELETEA(m_callbackDL);
KLBDELETEA(m_callbackFinish);
KLBDELETEA(m_callbackError);
KLBDELETE(m_unzip);
}
void
CKLBLuaLibMatrix::delMatrix(MATRIX * pMat)
{
if(!pMat) return;
if(pMat->prev) {
pMat->prev->next = pMat->next;
} else {
m_pBegin = pMat->next;
}
if(pMat->next) {
pMat->next->prev = pMat->prev;
} else {
m_pEnd = pMat->prev;
}
KLBDELETEA(pMat->name);
KLBDELETE(pMat);
}
// Shaders.
CShader* CKLBOGLWrapper::createShader (const char* source, SHADER_TYPE type, const SParam* listParam) {
CShader* pNewShader = KLBNEW(CShader);
if (pNewShader) {
GLuint shaderID = dglCreateShader(type == VERTEX_SHADER ? GL_VERTEX_SHADER : GL_FRAGMENT_SHADER);
if (shaderID != 0) {
GLint compiled;
dglShaderSource(shaderID, 1, &source, null);
// Compile the shader
dglCompileShader(shaderID);
// Check the compile status
dglGetShaderiv(shaderID, GL_COMPILE_STATUS, &compiled);
if (compiled) {
//
// Parse the list of parameters
//
const SParam* parser = listParam;
bool type;
if (parser) {
s32 uniCount = 0;
s32 verCount = 0;
while (parser->dType != END_LIST) {
if (parser->isUniform) {
uniCount++;
} else {
verCount++;
}
if (parser->dType & TEXTURE) {
pNewShader->enableTexture = true;
}
if (parser->dType & COLOR) {
pNewShader->enableColor = true;
}
parser++;
}
pNewShader->countUniform = uniCount;
pNewShader->countStreamInfo = verCount;
pNewShader->arrayParam = KLBNEWA(CShader::SInternalParam,uniCount + verCount);
if (pNewShader->arrayParam) {
CShader::SInternalParam* pUniParam = pNewShader->arrayParam;
CShader::SInternalParam* pVerParam = &pNewShader->arrayParam[uniCount];
parser = listParam;
while (parser->dType != END_LIST) {
if (parser->isUniform) {
pUniParam->param = *parser++;
pUniParam++;
} else {
pVerParam->param = *parser++;
pVerParam++;
}
}
}
type = true;
} else {
pNewShader->countUniform = 0;
pNewShader->countStreamInfo = 0;
pNewShader->arrayParam = null;
type = false;
}
if ((pNewShader->arrayParam && type) || (!type)) {
pNewShader->refCount = 0;
pNewShader->shaderObj = shaderID;
pNewShader->pNext = this->shaderList;
this->shaderList = pNewShader;
return pNewShader;
}
}
dglDeleteShader(shaderID);
}
KLBDELETE(pNewShader);
pNewShader = null;
}
return pNewShader;
}
// Rendering Shader.
CShaderSet* CKLBOGLWrapper::createShaderSet (CShader* pVertexShader, CShader* pPixelShader) {
CShaderSet* pNewShaderSet = KLBNEW(CShaderSet);
if (pNewShaderSet) {
s32 size = pVertexShader->countUniform + pPixelShader->countUniform;
if (size) {
pNewShaderSet->locationArray = KLBNEWA(s32,size);
} else {
pNewShaderSet->locationArray = null;
}
if ((pNewShaderSet->locationArray) || (size == 0)) {
GLuint progID = dglCreateProgram();
if (progID) {
// Attach
dglAttachShader(progID, pVertexShader->shaderObj);
dglAttachShader(progID, pPixelShader->shaderObj);
pNewShaderSet->pInstances = null;
pNewShaderSet->pMgr = this;
//
// Iterate through vertex shader attribute
//
s32 iterator = 0;
CShader::SInternalParam* pParam = &pVertexShader->arrayParam[pVertexShader->countUniform];
while (iterator < pVertexShader->countStreamInfo) {
dglBindAttribLocation(progID, iterator, pParam->param.name); // Actually only associated with vertex.
iterator++;
pParam++;
}
dglLinkProgram(progID);
GLint success = 0;
dglGetProgramiv(progID, GL_LINK_STATUS, &success);
if (success)
{
s32 uniformIndex = 0;
for (s32 n=0; n < 2; n++) {
CShader* pShader;
if (n==0) {
pShader = pVertexShader;
}
else {
pShader = pPixelShader;
}
CShader::SInternalParam* pParam = pShader->arrayParam;
iterator = 0;
while (iterator < pShader->countUniform) {
// Becomes UniformID
pNewShaderSet->locationArray[uniformIndex++] = dglGetUniformLocation(progID, pParam->param.name);
iterator++;
pParam++;
}
}
pNewShaderSet->programObj = progID;
pNewShaderSet->pNext = this->shaderSetList;
this->shaderSetList = pNewShaderSet;
pVertexShader->refCount++;
pPixelShader->refCount++;
pNewShaderSet->pixelShader = pPixelShader;
pNewShaderSet->vertexShader = pVertexShader;
pNewShaderSet->enableTexture = pPixelShader->enableTexture | pVertexShader->enableTexture;
pNewShaderSet->enableColor = pPixelShader->enableColor | pVertexShader->enableColor;
return pNewShaderSet;
}
dglDeleteProgram(progID);
}
if (pNewShaderSet->locationArray) {
KLBDELETE(pNewShaderSet->locationArray);
}
}
KLBDELETE(pNewShaderSet);
}
return null;
}
