C++ Sprite3D类代码示例

void Sprite3D::createAsync(const std::string &modelPath, const std::string &texturePath, const std::function<void(Sprite3D*, void*)>& callback, void* callbackparam)
{
    Sprite3D *sprite = new (std::nothrow) Sprite3D();
    if (sprite->loadFromCache(modelPath))
    {
        sprite->autorelease();
        if (!texturePath.empty())
            sprite->setTexture(texturePath);
        callback(sprite, callbackparam);
        return;
    }
    
    sprite->_asyncLoadParam.afterLoadCallback = callback;
    sprite->_asyncLoadParam.texPath = texturePath;
    sprite->_asyncLoadParam.modlePath = modelPath;
    sprite->_asyncLoadParam.callbackParam = callbackparam;
    sprite->_asyncLoadParam.materialdatas = new (std::nothrow) MaterialDatas();
    sprite->_asyncLoadParam.meshdatas = new (std::nothrow) MeshDatas();
    sprite->_asyncLoadParam.nodeDatas = new (std::nothrow) NodeDatas();
    AsyncTaskPool::getInstance()->enqueue(AsyncTaskPool::TaskType::TASK_IO, CC_CALLBACK_1(Sprite3D::afterAsyncLoad, sprite), (void*)(&sprite->_asyncLoadParam), [sprite]()
    {
        sprite->_asyncLoadParam.result = sprite->loadFromFile(sprite->_asyncLoadParam.modlePath, sprite->_asyncLoadParam.nodeDatas, sprite->_asyncLoadParam.meshdatas, sprite->_asyncLoadParam.materialdatas);
    });
    
}

void CoinAction::step(float time)
{
	if(_target)
	{
		_target->setRotation3D(Vec3(90,angle,180));
		angle+=time*140;
		_target->setPosition3D (_target->getPosition3D()+Vec3(0,0,100*time));
		if(_target->getPositionZ()>-40 && _target->getPositionZ()<10 )// enter the front
		{
            
			Sprite3D * sprite = dynamic_cast<Sprite3D * >(_target);
            OBB obb(sprite->getAABB());
      
			Vec3 vertices[8];
			auto player_aabb= player->getPlayer()->getAABB();
            auto dist =sprite->getPosition3D().distance(player->getPlayer()->getPosition3D());
            if(dist<5 && !is_triggered)
            {
                is_triggered =~is_triggered;
                sprite->setColor(Color3B(255,0,0));
                Effect::CoinEffect(render_node);
                auto a = (GameScene * )this->render_node;
                a->earnGold();
                CCLOG("get Money !!!");
                return ;
            }
		}
		if(_target->getPositionZ()>=10)
		{
			_target->removeFromParent();
			_target=nullptr;
		}
	}
}

bool LoadingLayer::init()
{
    if(!LayerColor::init())
        return false;
    
    //Set the background color
    LoadingLayer::setColor(Color3B::WHITE);
    
    Size visibleSize = Director::getInstance()->getVisibleSize();
    Vec2 origin = Director::getInstance()->getVisibleOrigin();

    Vec2 centerPoint = Utils::Utils::getCentralPoint(visibleSize, origin);
    
    //Load a planet sprite to show while the game loads
    Sprite3D* sprPlanet = Sprite3D::create("3d/meshes/MarsPlanet.obj", "3d/textures/MarsMap.jpg");
    sprPlanet->setPosition(centerPoint);
    Utils::Utils::setScale3D(10, sprPlanet);
    sprPlanet->runAction(RepeatForever::create(RotateBy::create(3,Vec3(0,360,0))));
    
    //Load the sprite with "LOADING..." string while the game loads
    Text* loadingText = Text::create("LOADING...", DEFAULT_FONT, 34);
    loadingText->setPosition(Vec2(sprPlanet->getPositionX(), SCREEN_FRAME_OFFSET));
    
    //Add elements as layer children
    addChild(sprPlanet);
    addChild(loadingText);
    
    return true;
}

 Node* Sprite3DReader::createNodeWithFlatBuffers(const flatbuffers::Table *sprite3DOptions)
 {
     auto options = (Sprite3DOptions*)sprite3DOptions;
     
     auto fileData = options->fileData();
     std::string path = fileData->path()->c_str();
     
     Sprite3D* ret = Sprite3D::create();
     if(FileUtils::getInstance()->isFileExist(path))
     {
         ret->initWithFile(path);
     }
     
     setPropsWithFlatBuffers(ret, sprite3DOptions);
     
     return ret;
 }

//! called before the action start. It will also set the target.
void Animate3D::startWithTarget(Node *target)
{
    Sprite3D* sprite = dynamic_cast<Sprite3D*>(target);
    CCASSERT(sprite && sprite->getSkeleton() && _animation, "Animate3D apply to Sprite3D only");
    
    ActionInterval::startWithTarget(target);
    
    _boneCurves.clear();
    auto skin = sprite->getSkeleton();
    bool hasCurve = false;
    for (int  i = 0; i < skin->getBoneCount(); i++) {
        auto bone = skin->getBoneByIndex(static_cast<unsigned int>(i));
        auto curve = _animation->getBoneCurveByName(bone->getName());
        if (curve)
        {
            _boneCurves[bone] = curve;
            hasCurve = true;
        }
    }
    if (!hasCurve)
    {
        CCLOG("warning: no animation finde for the skeleton");
    }
    
    auto runningAction = s_runningAnimates.find(sprite);
    if (runningAction != s_runningAnimates.end())
    {
        //make the running action fade out
        auto action = (*runningAction).second;
        if (action != this)
        {
            if (_transTime < 0.001f)
            {
                s_runningAnimates[sprite] = this;
                _state = Animate3D::Animate3DState::Running;
                _weight = 1.0f;
            }
            else
            {
                s_fadeOutAnimates[sprite] = action;
                action->_state = Animate3D::Animate3DState::FadeOut;
                action->_accTransTime = 0.0f;
                action->_weight = 1.0f;
                action->_lastTime = 0.f;
                
                s_fadeInAnimates[sprite] = this;
                _accTransTime = 0.0f;
                _state = Animate3D::Animate3DState::FadeIn;
                _weight = 0.f;
                _lastTime = 0.f;
            }
        }
    }
    else
    {
        s_runningAnimates[sprite] = this;
        _state = Animate3D::Animate3DState::Running;
        _weight = 1.0f;
    }
}

void PUParticle3DModelRender::render( Renderer* renderer, const Mat4 &transform, ParticleSystem3D* particleSystem )
{
    if (!_isVisible)
        return;

    if (_spriteList.empty()) {
        for (unsigned int i = 0; i < particleSystem->getParticleQuota(); ++i) {
            Sprite3D *sprite = Sprite3D::create(_modelFile);
            if (sprite == nullptr)
            {
                CCLOG("failed to load file %s", _modelFile.c_str());
                continue;
            }
            sprite->setTexture(_texFile);
            sprite->setBlendFunc(particleSystem->getBlendFunc());
            sprite->setCullFaceEnabled(false);
            sprite->retain();
            _spriteList.push_back(sprite);
        }
        if (!_spriteList.empty()) {
            const AABB &aabb = _spriteList[0]->getAABB();
            Vec3 corners[8];
            aabb.getCorners(corners);
            _spriteSize = corners[3] - corners[6];
        } else {
            _isVisible = false;
            return;
        }
    }


    const ParticlePool& particlePool = particleSystem->getParticlePool();
    ParticlePool::PoolList activeParticleList = particlePool.getActiveDataList();
    Mat4 mat;
    Mat4 rotMat;
    Mat4 sclMat;
    Quaternion q;
    transform.decompose(nullptr, &q, nullptr);
    unsigned int index = 0;
    for (auto iter : activeParticleList)
    {
        auto particle = static_cast<PUParticle3D *>(iter);
        Mat4::createRotation(q * particle->orientation, &rotMat);
        sclMat.m[0] = particle->width / _spriteSize.x;
        sclMat.m[5]  = particle->height / _spriteSize.y;
        sclMat.m[10] = particle->depth / _spriteSize.z;
        mat = rotMat * sclMat;
        mat.m[12] = particle->position.x;
        mat.m[13] = particle->position.y;
        mat.m[14] = particle->position.z;
        if (_spriteList[index]->getCameraMask() != particleSystem->getCameraMask())
            _spriteList[index]->setCameraMask(particleSystem->getCameraMask());
        _spriteList[index]->setColor(Color3B(particle->color.x * 255, particle->color.y * 255, particle->color.z * 255));
        _spriteList[index]->setOpacity(particle->color.w * 255);
        _spriteList[index]->visit(renderer, mat, Node::FLAGS_DIRTY_MASK);
        ++index;
    }
}

Sprite3D *MySprite3DFactory::create(cocos2d::MySpriteType type)
{
    
    Sprite3D *sp = Sprite3D::create(m_ModelFilesOfType[type]);
    if(sp)
    {
        sp->setAnchorPoint(Vec2(0, 1));
        sp->runAction(getAction(type));
    }
    return sp;
}

void	MainScene::update( float delta )
{
	Size visibleSize = Director::getInstance()->getVisibleSize();

	/*
	if( _inputLayer->isKeyboradPushDown( KEY_CODE::KEY_ENTER ) == true ) 
	{
		log( "enter push" );
	}

	if( _inputLayer->isKeyboradPushDown( KEY_CODE::KEY_ESCAPE ) == true ) 
	{
		log( "escape push" );
	}
*/

	Sprite3D* sprite = FileLoadManager::getInstance()->getSprite3D( _modelArray.size() );
	if( sprite != nullptr )
	{
		sprite->setPosition( visibleSize.width * 0.5f, visibleSize.height * 0.5f );
		sprite->setScale( 300.0f );
		addChild( sprite );
		_modelArray.pushBack( sprite );
	}

	
	if( _selectModel != nullptr )
	{
		_selectModel->setScale( _selectModel->getScale() + _inputLayer->getMouseScroll() * 2.0f );
		_selectModel->setPosition( CCPoint( _inputLayer->getMousePosition().x, _inputLayer->getMousePosition().y - (_selectModel->getContentSize().height * _selectModel->getScale()) * 0.5f ));
	}

	if( _inputLayer->isMousePush( InputLayer::MouseFlags::LEFT_PUSH_FlAG ) == true && _selectModel == nullptr)
	{
		for( int i = 0; i < (int)_modelArray.size(); i++ )
		{
			auto rect = _modelArray.at( i )->getBoundingBox();
			if( rect.containsPoint( _inputLayer->getMousePosition() ) == true )
			{
				log( "Model Push" );
				_selectModel = _modelArray.at( i );
			}
		}
	}
	else
	{
		_selectModel = nullptr;
	}
}

AABB Sprite3D::getAABBRecursively()
{
    AABB aabb;
    const auto children = getChildren();
    for (const auto iter: children)
    {
        Sprite3D* child = dynamic_cast<Sprite3D*>(iter);
        if(child)
        {
            aabb.merge(child->getAABBRecursively());
        }
    }
    aabb.merge(getAABB());
    return aabb;
}

void GameRenderer::renderAgent(const Agent * _agent) const
{
	dl::Point3D pos = _agent->getPosition();

	//Draw the guy
	glColor3f(1.0, 1.0, 1.0);

	glEnable(GL_TEXTURE_2D);

	m_agentTexture.bind();

	glTranslatef(pos.x, pos.y, pos.z);

		Sprite3D sprite;

		if((dl::Vector2D)_agent->getVelocity() != dl::Vector2D(0, 0))
			sprite.setStepping(m_stepping);

		if(_agent->getDirection().i > 0)
			if(_agent->getDirection().j > 0)
				sprite.setOrientation(Sprite3D::RIGHT_BACK);
			else
				sprite.setOrientation(Sprite3D::RIGHT_FRONT);
		else
			if(_agent->getDirection().j > 0)
				sprite.setOrientation(Sprite3D::LEFT_BACK);
			else
				sprite.setOrientation(Sprite3D::LEFT_FRONT);

		sprite.render();

	glTranslatef(-pos.x, -pos.y, -pos.z);

	glDisable(GL_TEXTURE_2D);
}

void WTest3D::showSprite3D()
{
	//the assets are from the OpenVR demo
	//get the visible size.
	Size size = Director::getInstance()->getVisibleSize();
	float zeye = Director::getInstance()->getZEye();
	Vec3 eye(size.width / 2, size.height / 2.0f, zeye),
		center(size.width / 2, size.height / 2, 0.0f),
		up(0.0f, 1.0f, 0.0f);
	_camera = Camera::createPerspective(60, size.width / size.height, 100, 3000);// zeye + size.height / 2.0f);
	_camera->setCameraFlag(CameraFlag::USER1);
	//_camera->setPosition3D(Vec3(0, 25, 15));
	_camera->setPosition3D(eye + Vec3(0, 60, 10));
	//_camera->lookAt(center, up);
	//_camera->setRotation3D(Vec3(-35, 0, 0));
	//auto LightMapScene = Sprite3D::create("Sprite3DTest/boss1.obj");
	//LightMapScene->setTexture("Sprite3DTest/boss.png");
	//auto LightMapScene = Sprite3D::create("Sprite3DTest/aaaa.c3b");
	addChild(_camera);
	setCameraMask(2);

	std::string fileName = "Sprite3DTest/orc.c3b";
	//std::string fileName = "Sprite3DTest/cccc.c3b";
	for (int i = 0; i < 14; ++i)
	{
		auto LightMapScene = Sprite3D::create(fileName);
		LightMapScene->setScale(8);
		addChild(LightMapScene, 100 + i, 100 + i);

		LightMapScene->setRotation3D(Vec3(0, 180, 0));
		auto sc = LightMapScene->getScale();
		auto sz = LightMapScene->getContentSize();
		auto curY = _terrain->getHeight(Vec2(250 + i*(sc*sz.width - 150), 10));
		LightMapScene->setPosition3D(Vec3(250 + i*(sc*sz.width - 150), curY, 10));
	}

	for (int i = 0; i < 14; ++i)
	{
		auto LightMapScene = Sprite3D::create(fileName);
		LightMapScene->setScale(8);
		addChild(LightMapScene, 200 + i, 200 + i);

		LightMapScene->setRotation3D(Vec3(0, 0, 0));
		auto sc = LightMapScene->getScale();
		auto sz = LightMapScene->getContentSize();
		auto curY = _terrain->getHeight(Vec2(250 + i*(sc*sz.width - 150), -1500));
		LightMapScene->setPosition3D(Vec3(250 + i*(sc*sz.width - 150), curY, -1500));
	}

	for (int i = 0; i < 14; ++i)
	{
		auto LightMapScene = Sprite3D::create(fileName);
		LightMapScene->setScale(8);
		addChild(LightMapScene, 300 + i, 300 + i);

		LightMapScene->setRotation3D(Vec3(0, 90, 0));
		auto sc = LightMapScene->getScale();
		auto sz = LightMapScene->getContentSize();
		auto curY = _terrain->getHeight(Vec2(20, -400 - i * 80));
		LightMapScene->setPosition3D(Vec3(20, curY, -400 - i * 80));
	}

	for (int i = 0; i < 14; ++i)
	{
		auto LightMapScene = Sprite3D::create(fileName);
		LightMapScene->setScale(8);
		addChild(LightMapScene, 400 + i, 400 + i);

		LightMapScene->setRotation3D(Vec3(0, 270, 0));
		auto sc = LightMapScene->getScale();
		auto sz = LightMapScene->getContentSize();
		auto curY = _terrain->getHeight(Vec2(1200, -400 - i * 80));
		LightMapScene->setPosition3D(Vec3(1200, curY, -400 - i * 80));
	}

	//for (int i = 0; i < 10; ++i)
	//{
	//	auto LightMapScene = Sprite3D::create(fileName);
	//	LightMapScene->setScale(8);
	//	addChild(LightMapScene, i, i);

	//	LightMapScene->setRotation3D(Vec3(90, 180, 0));
	//	auto sc = LightMapScene->getScale();
	//	auto sz = LightMapScene->getContentSize();
	//	CCLOG("getContentSize().width = %f, getContentSize().height = %f",
	//		getContentSize().width, getContentSize().height);
	//	LightMapScene->setPosition3D(Vec3(200 + i*(sc*sz.width - 150), 100, -300));
	//}

	Sprite3D* temp = (Sprite3D*)getChildByTag(100 + 13);
	CCLOG("getPositionX() = %f, getPositionY() = %f, getPositionZ = %f",
		temp->getPositionX(), temp->getPositionY(), temp->getPositionZ());
	CCLOG("getScaleX() = %f, getScaleX() = %f, getScaleZ = %f",
		temp->getScaleX(), temp->getScaleY(), temp->getScaleZ());
	CCLOG("getContentSize().width = %f, getContentSize().height = %f",
		temp->getContentSize().width, temp->getContentSize().height);
	CCLOG("getAnchorPoint().x = %f, getAnchorPoint().y = %f",
		temp->getAnchorPoint().x, temp->getAnchorPoint().y);

	//actions
//.........这里部分代码省略.........

//! called before the action start. It will also set the target.
void Animate3D::startWithTarget(Node *target)
{
    bool needReMap = (_target != target);
    ActionInterval::startWithTarget(target);
    
    if (needReMap)
    {
        _boneCurves.clear();
        _nodeCurves.clear();
        
        bool hasCurve = false;
        Sprite3D* sprite = dynamic_cast<Sprite3D*>(target);
        
        if(sprite)
        {
            if (_animation)
            {
                const std::unordered_map<std::string, Animation3D::Curve*>& boneCurves = _animation->getBoneCurves();
                for (const auto& iter: boneCurves)
                {
                    const std::string& boneName = iter.first;
                    auto skin = sprite->getSkeleton();
                    if(skin)
                    {
                        auto bone = skin->getBoneByName(boneName);
                        if (bone)
                        {
                            auto curve = _animation->getBoneCurveByName(boneName);
                            _boneCurves[bone] = curve;
                            hasCurve = true;
                        }
                        else
                        {
                            Node* node = nullptr;
                            if (target->getName() == boneName)
                                node = target;
                            else
                                node = findChildByNameRecursively(target, boneName);
                            
                            if (node)
                            {
                                auto curve = _animation->getBoneCurveByName(boneName);
                                if (curve)
                                {
                                    _nodeCurves[node] = curve;
                                    hasCurve = true;
                                }
                            }
                        }
                    }
                }
            }
        }
        else
        {
            const std::unordered_map<std::string, Animation3D::Curve*>& boneCurves = _animation->getBoneCurves();
            for (const auto& iter: boneCurves)
            {
                const std::string& boneName = iter.first;
                Node* node = nullptr;
                if (target->getName() == boneName)
                    node = target;
                else
                    node = findChildByNameRecursively(target, boneName);
                
                if (node)
                {
                    auto curve = _animation->getBoneCurveByName(boneName);
                    if (curve)
                    {
                        _nodeCurves[node] = curve;
                        hasCurve = true;
                    }
                }
                
            }
        }
        
        if (!hasCurve)
        {
            CCLOG("warning: no animation found for the skeleton");
        }
    }
    
    auto runningAction = s_runningAnimates.find(target);
    if (runningAction != s_runningAnimates.end())
    {
        //make the running action fade out
        auto action = (*runningAction).second;
        if (action != this)
        {
            if (_transTime < 0.001f)
            {
                s_runningAnimates[target] = this;
                _state = Animate3D::Animate3DState::Running;
                _weight = 1.0f;
            }
            else
            {
//.........这里部分代码省略.........

// on "init" you need to initialize your instance
bool Sprite3DLesson5::init()
{
    //////////////////////////////
    // 1. super init first
    if ( !Layer::init() )
    {
        return false;
    }
    
    Size visibleSize = Director::getInstance()->getVisibleSize();
    Vec2 origin = Director::getInstance()->getVisibleOrigin();

    /////////////////////////////
    // 2. add a menu item with "X" image, which is clicked to quit the program
    //    you may modify it.

    // add a "close" icon to exit the progress. it's an autorelease object
    auto closeItem = MenuItemImage::create(
                                           "CloseNormal.png",
                                           "CloseSelected.png",
                                           CC_CALLBACK_1(Sprite3DLesson5::menuCloseCallback, this));
    
	closeItem->setPosition(Vec2(origin.x + visibleSize.width - closeItem->getContentSize().width/2 ,
                                origin.y + closeItem->getContentSize().height/2));

    // create menu, it's an autorelease object
    auto menu = Menu::create(closeItem, NULL);
    menu->setPosition(Vec2::ZERO);
    this->addChild(menu, 1);
    
    auto listener = EventListenerTouchAllAtOnce::create();
    listener->onTouchesEnded = CC_CALLBACK_2(Sprite3DLesson5::onTouchesEnded, this);
    _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);

    /////////////////////////////
    std::string filename = "res/Sprite3D/girl.c3b";
    auto sprite = Sprite3D::create(filename);
    sprite->setPosition(visibleSize.width/2 + origin.x, visibleSize.height/3 + origin.y);
    addChild(sprite);
    
    auto animation = Animation3D::create(filename);
    auto animate = Animate3D::create(animation);
    sprite->runAction(RepeatForever::create(animate));
    
    auto lfoot = Sprite::create("res/Sprite3D/circle.png");
    auto rfoot = Sprite::create("res/Sprite3D/circle.png");
    _lfoot = Sprite3D::create();
    _lfoot->addChild(lfoot);
    _lfoot->setRotation3D(Vec3(90, 0, 0));
    _rfoot = Sprite3D::create();
    _rfoot->addChild(rfoot);
    _rfoot->setRotation3D(Vec3(90, 0, 0));
    
    addChild(_lfoot);
    addChild(_rfoot);
    _lfoot->setScale(0.3f);
    _rfoot->setScale(0.3f);
    _lfoot->setVisible(false);
    _rfoot->setVisible(false);
    
    _sprite = sprite;
    
    ValueMap valuemap0;
    valuemap0["footname"] = Value("Bip001 R Toe0");
    valuemap0["lfoot"] = Value(false);
    animate->setKeyFrameUserInfo(10, valuemap0);
    valuemap0["footname"] = Value("Bip001 L Toe0");
    valuemap0["lfoot"] = Value(true);
    animate->setKeyFrameUserInfo(26, valuemap0);
    auto listener2 = EventListenerCustom::create(Animate3DDisplayedNotification, [&](EventCustom* event)
    {
        auto info = (Animate3D::Animate3DDisplayedEventInfo*)event->getUserData();
        auto footname = info->userInfo->at("footname").asString();
        bool lfoot = info->userInfo->at("lfoot").asBool();
        auto mat = _sprite->getNodeToWorldTransform() * _sprite->getSkeleton()->getBoneByName(footname)->getWorldMat();
        Sprite3D* foot = lfoot ? _lfoot : _rfoot;
        foot->setPosition3D(Vec3(mat.m[12], mat.m[13], mat.m[14]));
        foot->setVisible(true);
        cocos2d::log("frame %d", info->frame);
    });
    Director::getInstance()->getEventDispatcher()->addEventListenerWithFixedPriority(listener2, -1);
    
    scheduleUpdate();
    return true;
}