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; }