void Resources::add(Resource* r, bool accessByShortenID)
{
OX_ASSERT(r);
if (!r)
return;
std::string name = lower(r->getName());
r->setName(name);
_resourcesMap[name] = r;
if (accessByShortenID)
{
std::string shortName = path::extractFileName(name);
if (shortName != name)
{
#ifdef OX_DEBUG
OX_ASSERT(_resourcesMap.find(shortName) == _resourcesMap.end());
if (_resourcesMap.find(shortName) != _resourcesMap.end())
{
logs::error("short resource name '%s' conflicts with '%s'", r->getName().c_str(), _resourcesMap[shortName]->getName().c_str());
}
#endif
_resourcesMap[shortName] = r;
}
}
}
void splitExt(const char *src, char *destHead, char *destTail)
{
OX_ASSERT(src != destHead);
OX_ASSERT(src != destTail);
destHead[0] = 0;
destTail[0] = 0;
int len = strlen(src);
int i = 0;
for (i = len - 1; i >= 0; --i)
{
if (src[i] == '.')
break;
}
if (i == -1)
i = len;
memcpy(destHead, src, i);
destHead[i] = 0;
int n = len - i;
memcpy(destTail, src + i, n);
destTail[n] = 0;
}
void Tween::complete(timeMS deltaTime)
{
if (_loops == -1)
return;
//if already done
if (_status >= status_done)
return;
OX_ASSERT(_client);
//OX_ASSERT(!"not implemented");
//not started yet because has delay
if (_status == status_delayed)
{
_start(*_client);
_status = status_started;
}
OX_ASSERT(_status == status_started);
//while (_status != status_remove)
{
UpdateState us;
us.dt = deltaTime;
update(*_client, us);
}
OX_ASSERT(_status == status_done);
//_client->removeTween(this);
}
void split(const char *src, char *destHead, char *destTail)
{
OX_ASSERT(src != destHead);
OX_ASSERT(src != destTail);
destHead[0] = 0;
destTail[0] = 0;
int i = 0;
int len = strlen(src);
while (len)
{
char c = src[len-1];
if (c == '\\' || c == '/')
{
break;
}
destTail[i] = c;
++i;
--len;
}
destTail[i] = 0;
reverse(destTail);
memcpy(destHead, src, len);
destHead[len] = 0;
}
void STDRenderer::setTexture(spNativeTexture base, spNativeTexture alpha, bool basePremultiplied)
{
if (base == 0 || base->getHandle() == 0)
base = white;
unsigned int shaderFlags = _shaderFlags;
if (basePremultiplied)
shaderFlags &= ~UberShaderProgram::ALPHA_PREMULTIPLY;
else
shaderFlags |= UberShaderProgram::ALPHA_PREMULTIPLY;
if (alpha)
shaderFlags |= UberShaderProgram::SEPARATE_ALPHA;
else
shaderFlags &= ~UberShaderProgram::SEPARATE_ALPHA;
//##ifdef OX_DEBUG
#if 0
if (_base != base) { OX_ASSERT(_alpha != alpha); }
else { OX_ASSERT(_alpha == alpha); }
#endif //OX_DEBUG
//no reason to check changed alpha because it is in pair with base
if (_base != base || /*_alpha != alpha || */_shaderFlags != shaderFlags)
{
drawBatch();
}
_shaderFlags = shaderFlags;
_base = base;
_alpha = alpha;
}
ImageData NativeTextureGLES::lock(lock_flags flags, const Rect* src)
{
assert(_lockFlags == 0);
_lockFlags = flags;
Rect r(0, 0, _width, _height);
if (src)
r = *src;
OX_ASSERT(r.getX() + r.getWidth() <= _width);
OX_ASSERT(r.getY() + r.getHeight() <= _height);
_lockRect = r;
assert(_lockFlags != 0);
if (_lockRect.isEmpty())
{
OX_ASSERT(!"_lockRect.IsEmpty()");
return ImageData();
}
if (_data.empty())
{
//_data.resize(_width)
}
ImageData im = ImageData(_width, _height, (int)(_data.size() / _height), _format, &_data.front());
return im.getRect(_lockRect);
}
fileHandleZip(const file_entry *entry):_entry(entry)
{
int r = 0;
r = unzGoToFilePos(entry->zp, const_cast<unz_file_pos*>(&entry->pos));
OX_ASSERT(r == UNZ_OK);
r = unzOpenCurrentFile(entry->zp);
OX_ASSERT(r == UNZ_OK);
}
void TweenAnim::setInterval(int start, int end)
{
_start = start;
_end = end;
int num = _row == -1 ? _resAnim->getTotalFrames() : _resAnim->getColumns();
OX_ASSERT(_start >= 0 && _start < num);
OX_ASSERT(_end >= 0 && _end < num);
}
ImageData ImageData::getRect(const Rect &r) const
{
OX_ASSERT(r.getX() + r.getWidth() <= w);
OX_ASSERT(r.getY() + r.getHeight() <= h);
void *ptr = (unsigned char*)data + r.getX() * bytespp + r.getY() * pitch;
ImageData buffer(r.getWidth(), r.getHeight(), pitch, format, ptr);
return buffer;
}
PointerState* Input::getTouchByIndex(pointer_index index_)
{
OX_ASSERT(index_ != 0);
int index = index_;
if (index == MAX_TOUCHES + 1)
return &_pointerMouse;
index -= 1;
OX_ASSERT(index >= 0 && index < MAX_TOUCHES);
index = std::min(std::max(index, 0), MAX_TOUCHES);
return &_pointers[index];
}
void Flow::phaseEnd()
{
_transition = false;
spScene current = _current;
spScene next = _next;
_current = 0;
_next = 0;
if ((next->_dialog && _back) || !next->_dialog)
{
current->_holder->detach();
current->postHiding();
}
getStage()->insertChildBefore(_touchBlocker, next->getHolder());
if (!_back || !current->_dialog)
next->postShowing();
if (_back)
next->sceneHidden(current);
getStage()->removeEventListener(TouchEvent::CLICK, CLOSURE(this, &Flow::blockedTouch));
if (current->_done)
{
current->leaving();
if (current->_resultCB)
{
current->_resultCB(¤t->_finishEvent);
current->_resultCB = resultCallback();
}
}
if (current->_remove)
{
OX_ASSERT(next->_dialog == false);
std::vector<spScene>::iterator i = std::find(scenes.begin(), scenes.end(), current);
OX_ASSERT(i != scenes.end());
scenes.erase(i);
}
if (_wasTouchBlocked)
{
log::messageln("send blocked touch");
TouchEvent click(TouchEvent::CLICK, true, _blockedTouchPosition);
getStage()->handleEvent(&click);
_wasTouchBlocked = false;
}
}
bool unitTest()
{
char dest[255];
//normalize("//", dest);
//OX_ASSERT(strcmp(dest, "/") == 0);
normalize("/../", dest);
OX_ASSERT(strcmp(dest, "../") == 0);
normalize("../c\\", dest);
OX_ASSERT(strcmp(dest, "../c/") == 0);
normalize("a//", dest);
OX_ASSERT(strcmp(dest, "a/") == 0);
normalize("\\/\\///\\/", dest);// \n
OX_ASSERT(strcmp(dest, "") == 0);
normalize("a/b/..\\//..///\\/../c\\\\/", dest);
OX_ASSERT(strcmp(dest, "../c/") == 0);
normalize("a/../c", dest);
OX_ASSERT(strcmp(dest, "c") == 0);
normalize("a/b/../../../c", dest);
OX_ASSERT(strcmp(dest, "../c") == 0);
normalize("..a/b/..\\//..///\\/../c\\\\/", dest);
OX_ASSERT(strcmp(dest, "../c/") == 0);
return true;
}
void ObjectBase::__generateID()
{
__id = ++_lastID;
//OX_ASSERT(_id != 889);
OX_ASSERT(_assertCtorID != __id);
}
void Resources::registerResourceType(Resources::createResourceCallback creationCallback, const char* resTypeID)
{
registeredResource r;
r.cb = creationCallback;
strcpy(r.id, resTypeID);
registeredResources::iterator it = std::lower_bound(_registeredResources.begin(), _registeredResources.end(), r.id, registeredResource::comparePred2);
if (it != _registeredResources.end())
{
if (!strcmp(it->id, resTypeID))
{
OX_ASSERT(!"resource already registered");
return;
}
}
_registeredResources.insert(it, r);
/*
for (it = _registeredResources.begin(); it != _registeredResources.end(); ++it)
{
registeredResource *q = &(*it);
int er =0 ;
}
*/
}
void STDRenderer::setBlendMode(blend_mode blend)
{
if (_blend != blend)
{
drawBatch();
switch (blend)
{
case blend_disabled:
_driver->setState(IVideoDriver::STATE_BLEND, 0);
break;
case blend_premultiplied_alpha:
_driver->setBlendFunc(IVideoDriver::BT_ONE, IVideoDriver::BT_ONE_MINUS_SRC_ALPHA);
break;
case blend_alpha:
_driver->setBlendFunc(IVideoDriver::BT_SRC_ALPHA, IVideoDriver::BT_ONE_MINUS_SRC_ALPHA);
break;
case blend_add:
_driver->setBlendFunc(IVideoDriver::BT_ONE, IVideoDriver::BT_ONE);
break;
//case blend_sub:
//_driver->setBlendFunc(IVideoDriver::BT_ONE, IVideoDriver::BT_ONE);
//glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
// break;
default:
OX_ASSERT(!"unknown blend");
}
if (_blend == blend_disabled)
{
_driver->setState(IVideoDriver::STATE_BLEND, 1);
}
_blend = blend;
}
}
int getBytesPerPixel(TextureFormat tf)
{
switch (tf)
{
case TF_A8:
case TF_L8:
return 1;
case TF_A8L8:
return 2;
case TF_R8G8B8A8:
case TF_B8G8R8A8:
return 4;
case TF_R8G8B8:
return 3;
case TF_R5G5B5A1:
return 2;
case TF_R5G6B5:
return 2;
case TF_R4G4B4A4:
return 2;
case TF_PVRTC_2RGB:
case TF_PVRTC_2RGBA:
case TF_PVRTC_4RGB:
case TF_PVRTC_4RGBA:
case TF_PVRTCII_2:
case TF_PVRTCII_4:
case TF_ETC1:
return 0;
case TF_UNDEFINED:
return 0;
default:
OX_ASSERT(!"unknown type");
}
return 0;
}
void HttpRequestTask::addHeader(const std::string& key, const std::string& value)
{
OX_ASSERT(!key.empty());
_headers.push_back(std::make_pair(key, value));
_addHeader(key, value);
}
void Zips::add(const char* name)
{
MutexAutoLock al(_lock);
zlib_filefunc_def zpfs;
memset(&zpfs, 0, sizeof(zpfs));
zpfs.zopen_file = ox_fopen;
zpfs.zread_file = ox_fread;
zpfs.zwrite_file = 0;
zpfs.ztell_file = ox_ftell;
zpfs.zseek_file = ox_fseek;
zpfs.zclose_file = ox_fclose;
zpfs.zerror_file = ox_ferror;
zpfs.opaque = (void*)_zps.size();
//zpfs.opaque = name;
unzFile zp = unzOpen2(name, &zpfs);//todo, optimize search in zip
OX_ASSERT(zp);
if (!zp)
return;
zpitem item;
item.handle = zp;
strcpy(item.name, name);
_zps.push_back(item);
read(zp);
}
DebugActor::DebugActor(): _frames(0), _startTime(0), _corner(0), _showTexel2PixelErrors(false), _showTouchedActor(false)
{
DebugActor::initialize();
setName(getDefaultName());
_startTime = getTimeMS();
setPriority(30000);
setTouchEnabled(false);
TextStyle st;
st.font = NULL;
if (ResFont* fnt = resSystem->getResFont("system"))
{
st.font = fnt->getFont();
}
OX_ASSERT(st.font != NULL);
st.vAlign = TextStyle::VALIGN_TOP;
//st.color = Color(rand()%255, rand()%255, rand()%255, 255);
st.color = Color(Color::Black, 255);
st.multiline = true;
setWidth(230);
setHeight(45);
_bg = new ColorRectSprite;
_bg->setColor(Color(Color::White, 64));
_bg->setSize(getSize());
_bg->setTouchEnabled(false);
addChild(_bg);
float x = getWidth();
addButton(x, "tree", "tree");
addButton(x, "finger", "finger");
#ifdef OXYGINE_DEBUG_T2P
addButton(x, "t2p", "t2p");
#endif
#ifdef OXYGINE_DEBUG_TRACE_LEAKS
addButton(x, "images", "images");
#endif
_text = new TextField;
addChild(_text);
_text->setPosition(2, 5);
_text->setTouchEnabled(false);
_text->setStyle(st);
_text->setWidth(getWidth());
_text->setText("debug text");
instance = this;
}
void SoundPlayer::removeSoundInstance(SoundInstance* soundInstance)
{
playingSounds::iterator i = std::find(_sounds.begin(), _sounds.end(), soundInstance);
OX_ASSERT(i != _sounds.end());
_sounds.erase(i);
}
void TweenAnim::update(Sprite& actor, float p, const UpdateState& us)
{
OX_ASSERT(_resAnim);
int frame;
if (p >= 1.0f)
p = 0.9999999f;
if (_start > _end)
frame = - int((_start + 1 - _end) * p);
else
frame = int((_end + 1 - _start) * p);
frame += _start;
/*
static int lastFrame = -1;
static int ltime = 0;
if (lastFrame != frame)
{
log::messageln("%d frame %d", getTimeMS() - ltime, frame);
ltime = getTimeMS();
}
lastFrame = frame;
*/
const AnimationFrame& fr = _row == -1 ? _resAnim->getFrame(frame) : _resAnim->getFrame(frame, _row);
_setAnimFrame(actor, fr);
}
void ResAnim::setFrame(int col, int row, const AnimationFrame& frame)
{
int i = row * _columns + col;
OX_ASSERT(i < (int)_frames.size());
if (i < (int)_frames.size())
_frames[i] = frame;
}
const AnimationFrame& ResAnim::getFrame(int index) const
{
OX_ASSERT(index < (int)_frames.size());
if (index < (int)_frames.size())
return _frames[index];
return emptyFrame;
}
void ThreadDispatcher::reply(void* val)
{
#ifndef OX_NO_MT
MutexPthreadLock lock(_mutex);
#endif
OX_ASSERT(_last.need_reply);
_replyLast(val);
}
unsigned int read(handle h, void* dest, unsigned int destSize)
{
fileHandle* fh = (fileHandle*)h;
OX_ASSERT(fh && dest);
LOGD("read file %x %d", fh, destSize);
return fh->read(dest, destSize);
}
void SoundInstance::setVolume(float v)
{
OX_ASSERT(v >= 0 && v <= 1.0f);
_volume = v;
if (_channel)
_channel->setVolume(_volume);
}
void Restorable::reg(RestoreCallback cb, void *user)
{
if (_registered)
return;
MutexAutoLock al(_mutex);
OX_ASSERT(_restoring == false);
_cb = cb;
_userData = user;
_registered = true;
restorable::iterator i = findRestorable(this);
OX_ASSERT(i == _restorable.end());
_restorable.push_back(this);
}
glPixel SurfaceFormat2GL(TextureFormat format)
{
glPixel pixel;
pixel.compressed = false;
//ADD_SF - dont remove this comment
switch (format)
{
case TF_R8G8B8A8:
pixel.format = GL_RGBA;
pixel.type = GL_UNSIGNED_BYTE;
break;
case TF_R5G6B5:
pixel.format = GL_RGB;
pixel.type = GL_UNSIGNED_SHORT_5_6_5;
break;
case TF_R4G4B4A4:
pixel.format = GL_RGBA;
pixel.type = GL_UNSIGNED_SHORT_4_4_4_4;
break;
case TF_R5G5B5A1:
pixel.format = GL_RGBA;
pixel.type = GL_UNSIGNED_SHORT_5_5_5_1;
break;
case TF_PVRTC_2RGB:
pixel.format = GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
pixel.type = 0;
pixel.compressed = true;
break;
case TF_PVRTC_2RGBA:
pixel.format = GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
pixel.type = 0;
pixel.compressed = true;
break;
case TF_PVRTC_4RGB:
pixel.format = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
pixel.type = 0;
pixel.compressed = true;
break;
case TF_PVRTC_4RGBA:
pixel.format = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
pixel.type = 0;
pixel.compressed = true;
break;
case TF_ETC1:
pixel.format = GL_ETC1_RGB8_OES;
pixel.type = 0;
pixel.compressed = true;
break;
default:
log::error("unknown format: %d\n", format);
OX_ASSERT(!"unknown format");
}
return pixel;
}
int yield()
{
OX_ASSERT(_mainLoopFunc);
#if OXYGINE_NO_YEILD
log::error("%s not supported", __func__);
return 0;
#endif
return _mainLoopFunc();
}
spTween TweenQueue::add(spTween t)
{
OX_ASSERT(t);
if (!t)
return 0;
_tweens.append(t);
return t;
}
