// Adds child at <code>index<code/>, or does nothing if <code>index<code/> greater than <code>numChildren</code>.
	void DisplayObject::addChildAt(DisplayObject * displayObject, unsigned int index)
	{
		if (index <= numChildren()) {
			std::vector<DisplayObject*>::iterator it;
			
			// Get iterator for index.
			it = _children.begin();
			it += index;
			
			// Insert child
			_children.insert(it, displayObject);
			displayObject->setParent(this);
			
			// hold on to it so it doesn't get freed.
			retain(displayObject);
		}
	}

void NetworkSprite::loadTexture() {
	if (_asset && _asset->isReadAvailable()) {
		auto cache = TextureCache::getInstance();

		Asset * asset = _asset;

		retain();
		cache->addTexture(_asset, [this, asset] (cocos2d::Texture2D *tex) {
			if (asset == _asset && tex) {
				setTexture(tex, Rect(0, 0, tex->getContentSize().width, tex->getContentSize().height));
			}
			release();
		}, _texture != nullptr);
	} else {
		setTexture(nullptr, Rect::ZERO);
	}
}

//--------------------------------------------------------------
void ofVbo::setVertexData(const float * vert0x, int numCoords, int total, int usage, int stride) {

#ifdef TARGET_OPENGLES
	if(!vaoChecked){
		if(ofGetGLProgrammableRenderer()){
			glGenVertexArrays = (glGenVertexArraysType)dlsym(RTLD_DEFAULT, "glGenVertexArrays");
			glDeleteVertexArrays =  (glDeleteVertexArraysType)dlsym(RTLD_DEFAULT, "glDeleteVertexArrays");
			glBindVertexArray =  (glBindVertexArrayType)dlsym(RTLD_DEFAULT, "glBindVertexArrayArrays");
		}else{
			glGenVertexArrays = (glGenVertexArraysType)dlsym(RTLD_DEFAULT, "glGenVertexArraysOES");
			glDeleteVertexArrays =  (glDeleteVertexArraysType)dlsym(RTLD_DEFAULT, "glDeleteVertexArraysOES");
			glBindVertexArray =  (glBindVertexArrayType)dlsym(RTLD_DEFAULT, "glBindVertexArrayArraysOES");
		}
		vaoChecked = true;
		supportVAOs = glGenVertexArrays && glDeleteVertexArrays && glBindVertexArray;
	}
#else
	if(!vaoChecked){
		supportVAOs = ofGetGLProgrammableRenderer() || glewIsSupported("GL_ARB_vertex_array_object");
		vaoChecked = true;
	}
#endif


	if(vertId==0) {
		bAllocated  = true;
		bUsingVerts = true;
		vaoChanged=true;
		glGenBuffers(1, &(vertId));
		retain(vertId);
		#if defined(TARGET_ANDROID) || defined(TARGET_OF_IOS)
			registerVbo(this);
		#endif
	}

	vertUsage = usage;
	vertSize = numCoords;
	vertStride = stride==0?3*sizeof(float):stride;
	totalVerts = total;
	
	glBindBuffer(GL_ARRAY_BUFFER, vertId);
	glBufferData(GL_ARRAY_BUFFER, total * stride, vert0x, usage);
	glBindBuffer(GL_ARRAY_BUFFER, 0);

}

int Application::run()
{
    initGLContextAttrs();
    // Initialize instance and cocos2d.
    if (! applicationDidFinishLaunching())
    {
        return 0;
    }

    long lastTime = 0L;
    long curTime = 0L;

    auto director = Director::getInstance();
    auto glview = director->getOpenGLView();

    // Retain glview to avoid glview being released in the while loop
    glview->retain();

    while (!glview->windowShouldClose())
    {
        lastTime = getCurrentMillSecond();

        director->mainLoop();
        glview->pollEvents();

        curTime = getCurrentMillSecond();
        if (curTime - lastTime < _animationInterval)
        {
            usleep((_animationInterval - curTime + lastTime)*1000);
        }
    }
    /* Only work on Desktop
    *  Director::mainLoop is really one frame logic
    *  when we want to close the window, we should call Director::end();
    *  then call Director::mainLoop to do release of internal resources
    */
    if (glview->isOpenGLReady())
    {
        director->end();
        director->mainLoop();
        director = nullptr;
    }
    glview->release();
    return -1;
}

bool AppDelegate::applicationDidFinishLaunching() {
    // initialize director
    auto director = Director::getInstance();
    auto glview = director->getOpenGLView();
    if(!glview) {
        glview = GLViewImpl::create("Starcraft");
        director->setOpenGLView(glview);
    }
    
    glview->setDesignResolutionSize(DISPLAY_WIDTH, DISPLAY_HEIGHT, ResolutionPolicy::SHOW_ALL);

    // turn on display FPS
    director->setDisplayStats(true);
    
    // set FPS. the default value is 1.0/60 if you don't call this
    director->setAnimationInterval(1.0 / 60);
    
    register_all_packages();
    
    ///////////////////////////로그인 서버로 접속

    if(PLAY_ALONE) {
        glview->setDesignResolutionSize(1280, 720, ResolutionPolicy::SHOW_ALL);
        auto scene = GameWorld::createScene();
        
        // run
        director->runWithScene(scene);
    }else{
        GameClient::GetInstance().Initialize();
        
        auto networkBGLayer = NetworkLayer::create();
        networkBGLayer->retain();
        
        GameClient::GetInstance().currentScene = NO_SCENE_NOW;
        
        Scene* scene = HelloWorld::createScene();
        
        scene->addChild(networkBGLayer, 0, TAG_NETWORK_LAYER);
        Director::getInstance()->runWithScene(scene);
        
        networkBGLayer->handler->frontSendFirstConnectReq();
    }

    return true;
}

ofVbo & ofVbo::operator=(const ofVbo& mom){
	if(&mom==this) return *this;
	clear();
	bUsingVerts = mom.bUsingVerts;
	bUsingTexCoords = mom.bUsingTexCoords;
	bUsingColors = mom.bUsingColors;
	bUsingNormals = mom.bUsingNormals;
	bUsingIndices = mom.bUsingIndices;

	vertSize		= mom.vertSize;
	vertStride      = mom.vertStride;
	colorStride		= mom.colorStride;
	normalStride    = mom.normalStride;
	texCoordStride  = mom.texCoordStride;

	vertUsage		= mom.vertUsage;
	colorUsage		= mom.colorUsage;
	normUsage		= mom.normUsage;
	texUsage		= mom.texUsage;

	vertId     = mom.vertId;
	retain(vertId);
	normalId   = mom.normalId;
	retain(normalId);
	colorId    = mom.colorId;
	retain(colorId);
	texCoordId = mom.texCoordId;
	retain(texCoordId);
	indexId    = mom.indexId;
	retain(indexId);
	if(supportVAOs){
		vaoID	   = mom.vaoID;
		retainVAO(vaoID);
		vaoChanged = mom.vaoChanged;
	}

	attributeIds = mom.attributeIds;
	for (map<int, GLuint>::iterator it = attributeIds.begin(); it != attributeIds.end(); it++){
		retain(it->second);
	}
	
	attributeNumCoords = mom.attributeNumCoords;
	attributeStrides = mom.attributeStrides;
	attributeSize = mom.attributeSize;
	
	totalVerts = mom.totalVerts;
	totalIndices = mom.totalIndices;

	bAllocated		= mom.bAllocated;
	bBound   = mom.bBound;
	return *this;
}

unsigned long Channel::push(Variant *var)
{
	if (!var)
		return 0;

	Lock l(mutex);
	var->retain();

	// Keep a reference to ourselves
	// if we're non-empty and named.
	if (named && queue.empty())
		retain();

	queue.push(var);
	cond->broadcast();

	return ++sent;
}

void HelloWorld::initScene()
{
    Size visibleSize = Director::getInstance()->getVisibleSize();
    auto vp = Camera::getDefaultViewport();
    auto node = CSLoader::createNode("res/Scene3DNoParticle.csb");
    node->setCameraMask((unsigned short)CameraFlag::USER1, true);
    addChild(node);
    _headNode = node->getChildByTag(57);
    {
        _camera = Camera::createPerspective(60,visibleSize.width/visibleSize.height * 0.5,0.1f,800);
        _camera->setCameraFlag(CameraFlag::USER1);
        //
        //        _camera->setPosition3D(Vec3(-0.01,0,0));
        _camera->setFrameBufferObject(Director::getInstance()->getDefaultFBO());
        _camera->setViewport(experimental::Viewport(vp._left,vp._bottom, vp._width/2, vp._height));
        _headNode->addChild(_camera);
        
        _camera2 = Camera::createPerspective(60,visibleSize.width/visibleSize.height * 0.5,0.1f,800);
        _camera2->setCameraFlag(CameraFlag::USER1);
        //
        //        _camera->setPosition3D(Vec3(-0.01,0,0));
        _camera2->setFrameBufferObject(Director::getInstance()->getDefaultFBO());
        _camera2->setViewport(experimental::Viewport(vp._left + vp._width/2,vp._bottom, vp._width/2, vp._height));
        _headNode->addChild(_camera2);
    }
    
    //add skybox
    {
        auto textureCube = TextureCube::create("skybox/left.jpg", "skybox/right.jpg",
                                           "skybox/top.jpg", "skybox/bottom.jpg",
                                           "skybox/front.jpg", "skybox/back.jpg");
        auto skyBox = Skybox::create();
        skyBox->retain();
        
        skyBox->setTexture(textureCube);
        addChild(skyBox);
        skyBox->setCameraMask((unsigned short)CameraFlag::USER1);
    }
    auto listener = EventListenerTouchOneByOne::create();
    listener->onTouchBegan = CC_CALLBACK_2(HelloWorld::onTouchBegan, this);
    listener->onTouchEnded = CC_CALLBACK_2(HelloWorld::onTouchEnded, this);
    _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
    CCASSERT(_headNode, "");
}

/**
 * @brief Reads a Boole from `reader`.
 * @param reader The JSONReader.
 * @return The Boole.
 */
static _Bool *readBoole(JSONReader *reader) {

	Boole *boolean = NULL;

	switch (*reader->b) {
		case 't':
			consumeBytes(reader, "true");
			boolean = $$(Boole, True);
			break;
		case 'f':
			consumeBytes(reader, "false");
			boolean = $$(Boole, False);
			break;
		default:
			assert(false);
	}

	return retain(boolean);
}

/**
 * @fn Array *Array::initWithArray(Array *self, const Array *array)
 *
 * @memberof Array
 */
static Array *initWithArray(Array *self, const Array *array) {

	self = (Array *) super(Object, self, init);
	if (self) {

		self->count = array->count;
		if (self->count) {

			self->elements = calloc(self->count, sizeof(ident));
			assert(self->elements);

			for (size_t i = 0; i < self->count; i++) {
				self->elements[i] = retain(array->elements[i]);
			}
		}
	}

	return self;
}

void CAAlertView::showMessage(std::string title, std::string alertMsg, std::vector<std::string>& vBtnText)
{
	setTitleImage(CAImage::create("source_material/alert_title.png"));
	setContentBackGroundImage(CAImage::create("source_material/alert_content.png"));
	setTitle(title.c_str(), CAColor_white);
	setAlertMessage(alertMsg.c_str());
	
	initAllButton(vBtnText);
	setAllBtnBackGroundImage(CAControlStateNormal, CAImage::create("source_material/alert_btn.png"));
	setAllBtnBackGroundImage(CAControlStateHighlighted, CAImage::create("source_material/alert_btn_sel.png"));
	setAllBtnTextColor();

	calcuCtrlsSize();

	CAApplication* pApplication = CAApplication::getApplication();
	CCAssert(pApplication != NULL, "");
	pApplication->getRootWindow()->insertSubview(this, CAWindowZoderCenter);
	retain();
}

//----------------------------------------
void ofLight::enable() {
	if(glIndex==-1){
		// search for the first free block
		for(int i=0; i<OF_MAX_LIGHTS; i++) {
			if(getActiveLights()[i] == false) {
				glIndex = i;
				retain(glIndex);
				enable();
				return;
			}
		}
	}
	if(glIndex!=-1) {
		ofEnableLighting();
		glEnable(GL_LIGHT0 + glIndex);
	}else{
		ofLog(OF_LOG_ERROR, "Trying to create too many lights: " + ofToString(glIndex));
	}
}

Goal::Goal():clampPos(nullptr){
	Sprite::init();
	_isDead = false;

	PhysicsBody* pb = PhysicsBody::createCircle(25);
	pb->setMass(1000.0f);
	pb->setDynamic(true);
	pb->setContactTestBitmask(true);
	setPhysicsBody(pb);
	setName("Goal");
	
	/*-------
	 当たり判定
	 --------*/
	auto c = CollisionDelegate<Goal>::create(this, &Goal::onContact);
	CollisionFuncManager::getInstance()->addFunc(this->getName(), c);

	retain();
}

bool IOFWSyncer::init(bool twoRetains)
{
    if (!OSObject::init())
        return false;

    if (!(guardLock = IOSimpleLockAlloc()) )
        return false;
	
    IOSimpleLockInit(guardLock);

    if(twoRetains)
	retain();

    fResult = kIOReturnSuccess;

    reinit();

    return true;
}

ARC<TextureProtocol>
SDLRenderer::textureFromImage(const std::string& image) {
    
    if(_textureCache.find(image) != _textureCache.end()) {
        return alloc<SDLTexture>(_textureCache[image]);
    }
    
    // TODO: Replace with cache call for SDL_Texture
    SDL_Texture* _sdl = IMG_LoadTexture(_renderer, image.c_str());
    if(_sdl == nullptr) {
        throw std::runtime_error(std::string("Error creating texture: ")+IMG_GetError());
    }
    SDL_SetTextureBlendMode(_sdl, SDL_BLENDMODE_BLEND);
    
    auto texture = alloc<SDLTextureRef>(_sdl);
    _textureCache[image] = texture;
    texture->retain();
    
    return alloc<SDLTexture>(texture);
}

obj udef_op0(obj ope, obj v){
	assert(type(ope)==tSymbol);
	obj lamb = find_var(ope);
	if(!lamb) return nil;
	assert(type(lamb)==tClosure);
	list ll = seek_lamb(ul(lamb), v);
	if(! ll) {
		return nil;
	}
	if(type(first(ll))==tInternalFn) error("user-defined operator not defined for the type.");
	obj vars = Assoc();
	bind_vars(&vars, first(ll), v);
	push(env);
	env = op(vars, retain(third(ll)));
	release(lamb);	//execÇÃǻǩÇ≈lambÇ™çÌèúÇ≥ÇÍÇÈâ¬î\ê´Ç†ÇË
	obj rr = exec(second(ll));
	release(env);
	env = pop(&is);
	return strip_return(rr);
}

 bp::Object * invoke(const std::string & functionName,
                     unsigned int id,
                     std::vector<const bp::Object *> args)
 {
     if (!functionName.compare("stop")) {
         m_rl->stop();            
     } else if (!functionName.compare("setTimeout")) {
         // extract arguments
         CPPUNIT_ASSERT( args.size() == 2 ); 
         unsigned int msec = (unsigned int) ((long long) *args[1]);
         CPPUNIT_ASSERT_EQUAL( args[0]->type(), BPTCallBack ); 
         m_tid = id;
         m_cb = bp::CallBack(*(args[0]));
         retain(id);
         m_t.setMsec(msec);
     } else {
         BP_THROW_FATAL("no such function");
     }
     return NULL;
 }

//----------------------------------------
void ofLight::enable() {
	if(glIndex==-1){
		bool bLightFound = false;
		// search for the first free block
		for(int i=0; i<OF_MAX_LIGHTS; i++) {
			if(getActiveLights()[i] == false) {
				glIndex = i;
				retain(glIndex);
				bLightFound = true;
				break;
			}
		}
		if( !bLightFound ){
			ofLog(OF_LOG_ERROR, "ofLight : Trying to create too many lights: " + ofToString(glIndex));
		}
	}
	
	ofEnableLighting();
	glEnable(GL_LIGHT0 + glIndex);
}

void DungeonLayer::reset() {
  _monsterRoomDatas.clear();
  this->removeAllChildren();
  
  auto initialRoom = Game::getInstance()->getDungeon()->getInitialRoom();
  auto initialCoordinate = INITIAL_COORDINATE;
  
  auto initialSprite = DungeonRoomSprite::createWithRoom(initialRoom);
  initialSprite->setCoordinate(initialCoordinate);
  
  this->addChild(initialSprite, DUNGEON_ROOM_WITH_CHAR_Z_ORDER);
  
  auto character = Game::getInstance()->getPlayer()->getCharacter();
  
  auto characterSprite = character->getSprite();
  characterSprite->retain();
  characterSprite->removeFromParent();
  characterSprite->setPosition(PositionUtil::centerOfNode(initialSprite));
  initialSprite->addChild(characterSprite);
  characterSprite->release();
}

//--------------------------------------------------------------
void ofVboByteColor::setVertexData(const float * vert0x, int numCoords, int total, int usage, int stride) {
	if(vert0x == NULL) {
		ofLog(OF_LOG_WARNING,"ofVboByteColor: bad vertex data!\n");
		return;	
	}
	if(vertId==0) {
		bAllocated  = true;
		bUsingVerts = true;
		glGenBuffers(1, &(vertId));
		retain(vertId);
	}

	vertUsage = usage;
	vertSize = numCoords;
	vertStride = stride;
	totalVerts = total;
	
	glBindBuffer(GL_ARRAY_BUFFER, vertId);
	glBufferData(GL_ARRAY_BUFFER, total * stride, vert0x, usage);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
}