/*static*/
IDataSource* JSonDB::openDB(const u8* source, u32 sourceLength) {
JSonDB* newDB = KLBNEW(JSonDB);
if (!newDB->readDBInternal(source, sourceLength)) {
KLBDELETE(newDB);
newDB = NULL;
}
return newDB;
}
CKLBDeviceKeyEvent *
CKLBDeviceKeyEvent::create()
{
CKLBDeviceKeyEvent * pTask = KLBNEW(CKLBDeviceKeyEvent);
if (pTask) {
pTask->regist(0, P_INPUT); // 入力タスクは必ず入力フェーズに指定する。
}
return pTask;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
CKLBLuaLibMatrix::MATRIX *
CKLBLuaLibMatrix::newMatrix()
{
MATRIX * pMat = KLBNEW(MATRIX);
if(!pMat) return NULL;
pMat->name = NULL;
pMat->prev = m_pEnd;
pMat->next = NULL;
if(pMat->prev) {
pMat->prev->next = pMat;
} else {
m_pBegin = pMat;
}
m_pEnd = pMat;
return pMat;
}
CKLBLuaLibFONT::FONTOBJ *
CKLBLuaLibFONT::create_font(int size, const char * fontname)
{
IPlatformRequest& pForm = CPFInterface::getInstance().platform();
void * font = pForm.getFont(size, fontname);
FONTOBJ * fontobj = (!font) ? NULL : KLBNEW(FONTOBJ);
if(fontobj) {
fontobj->font = font;
fontobj->size = size;
fontobj->prev = ms_end;
fontobj->next = NULL;
if(fontobj->prev) {
fontobj->prev->next = fontobj;
} else {
ms_begin = fontobj;
}
ms_end = fontobj;
}
return fontobj;
}
// 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;
}
bool
CKLBUIScore::initCore(u32 order, s32 order_offset, float x, float y,
const char ** tex_table, float stepX, float stepY, int column,
bool fillzero, bool anim_flag, u32 align, bool countclip)
{
if(!setupPropertyList((const char**)ms_propItems,SizeOfArray(ms_propItems))) {
return false;
}
setInitPos(x, y);
m_order = order;
m_orderOffset = order_offset;
m_stepX = (int)stepX;
m_stepY = (int)stepY;
m_column = column;
m_bFillZero = fillzero;
m_anim = anim_flag;
m_align = align;
m_bCountClip = countclip;
m_dotStepX = 0;
m_dotStepY = 0;
m_value = 0xFFFFFFFF;
m_fValue = -12345678.0f;
setValue(0);
setValueFloat(0.0f, 0);
RESET_B; // Reset flag done by setValueFloat.
// align設定用の幅を計算
m_width = stepX * column;
m_height = stepY * column;
// 保持できる最大値+1を計算
m_maxvalue = 1;
for(int i = 0; i < column; i++) { m_maxvalue = m_maxvalue * 10; }
for(int idx = 0; idx < 10; idx++) {
setStrC(m_asset[idx], tex_table[idx]);
}
CKLBTextureAsset * pTexAsset;
pTexAsset = (CKLBTextureAsset *)CKLBUtility::loadAssetScript( m_asset[0], &m_handle, NULL, true);
const char * texname[10];
for(int i = 0; i < 10; i++) {
texname[i] = m_asset[i] + 8;
}
m_pScoreNode = KLBNEW(CKLBScoreNode);
if(!m_pScoreNode) {
CKLBDataHandler::releaseHandle(m_handle);
return false;
}
for(int i = 0; i < 10; i++) {
m_numTex[i] = pTexAsset->getImage(texname[i]);
if(m_numTex[i] == 0) {
CKLBScriptEnv::getInstance().error("TEXB differs from [%s] by [%s].", texname[0], texname[i]);
CKLBDataHandler::releaseHandle(m_handle);
return false;
}
}
bool bResult = m_pScoreNode->init( order,
order_offset,
m_numTex,
m_stepX,
m_stepY,
column,
fillzero,
anim_flag);
getNode()->addNode(m_pScoreNode, 0);
m_pScoreNode->markUpMatrix();
m_bScoreUpdate = true;
if(!bResult) CKLBDataHandler::releaseHandle(m_handle);
return bResult;
}
/*virtual*/
CKLBNode* CKLBNode::clone(CKLBNode* newItem, CKLBNode* parent, CKLBNode* brother, bool transferSpriteOwnership) {
if (newItem == NULL) {
newItem = KLBNEW(CKLBNode);
}
if (newItem) {
//
// Recursive parse tree.
//
CKLBNode* pChild = m_pChild;
CKLBNode* pBrother = NULL;
while (pChild) {
pBrother = pChild->clone(NULL, newItem, pBrother, transferSpriteOwnership);
newItem->addNode(pBrother,pBrother->getLayer());
pChild = pChild->m_pBrother;
}
newItem->m_parent = parent;
newItem->m_matrix = m_matrix;
newItem->m_localColorMatrix = m_localColorMatrix;
// Disconnected by default : CTOR default.
// Recomputed when tree connect.
// SMatrix2D m_composedMatrix;
// SColorVector m_colorMatrix;
if (m_name) {
newItem->m_name = CKLBUtility::copyString(m_name);
}
newItem->m_uitask = m_uitask;
// Disconnected by default : CTOR default
// CKLBNode* m_pAnimationNext;
// CKLBNode* m_pAnimationPrev;
// m_isAnimated;
if (m_pColorMatrix != &m_colorMatrix) {
if (parent) {
newItem->m_pColorMatrix = parent->m_pColorMatrix;
}
}
if (m_pRender != &m_renderSlot) {
newItem->m_pRender = KLBNEWA(CKLBRenderCommand*,m_renderCount);
}
for (u32 n=0; n < m_renderCount; n++) {
if (transferSpriteOwnership) {
newItem->setRenderRef (this->getRender(n),n);
} else {
newItem->setRender (this->getRender(n),n);
}
}
newItem->m_rot = m_rot;
newItem->m_scaleX = m_scaleX;
newItem->m_scaleY = m_scaleY;
newItem->m_renderCount = m_renderCount;
newItem->m_groupID = m_groupID;
newItem->m_status = m_status | INVISIBLE_UPPER;
if (parent == NULL) {
newItem->m_status |= ANY_CHANGE | MARKED;
}
newItem->m_layer = m_layer;
newItem->m_movieID = m_movieID;
newItem->m_updateFrame = m_updateFrame;
newItem->m_nameLength = m_nameLength;
if (transferSpriteOwnership) {
// Clone now own the sprite
newItem->m_deleteRender = true;
this->m_deleteRender = false;
} else {
// Original own the sprite
newItem->m_deleteRender = false;
}
newItem->m_bInternalNode = m_bInternalNode;
newItem->m_useParentColor = m_useParentColor;
newItem->m_reject = m_reject;
}
