Irrlicht Engine

Code: Select all

//this being a CSprite (ISceneNode), later added with SceneManager->registerNodeForRendering(this);
            this->setMaterialFlag(video::EMF_LIGHTING, false);
            this->setMaterialTexture(0, driver->getTexture
                                                   ("images/explosion_1.png"));
            this->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
            this->setPosition(core::vector3df(0.f,0.f,0.f));
            this->setMaterialFlag(video::EMF_ZBUFFER,false);

Code: Select all

            scene::IBillboardSceneNode* light = 0;
            light = mgr->addBillboardSceneNode(0,
            core::dimension2d<f32>(255, 255));
            light->setMaterialFlag(video::EMF_LIGHTING, false);
            light->setMaterialTexture(0, driver->getTexture
                                                   ("images/explosion_1.png"));
            light->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
            light->setPosition(core::vector3df(0.f,0.f,0.f));
            light->setMaterialFlag(video::EMF_ZBUFFER,false);

Code: Select all

class CSprite : public ISceneNode 
{ 
    aabbox3d<f32> Box; // Implementation elided for brevity 
    S3DVertex     Vertices[4]; 
    SMaterial     Material; 
    dimension2df  Size; 
    f32           Rotation; 

public: 

    CSprite(dimension2df size, char const * textureName, E_MATERIAL_TYPE materialType, 
            bool makeColourKey, IVideoDriver * driver, ISceneNode* parent, ISceneManager* mgr, 
            s32 id = -1) 
        : ISceneNode(parent, mgr, id) 
    { 
        Material.Wireframe = false; 
        Material.Lighting = false; 
        Material.MaterialType = materialType; 

        if(driver && textureName) 
        { 
            ITexture * texture = driver->getTexture(textureName); 

            if(texture) 
            { 
                if(makeColourKey) 
                   driver->makeColorKeyTexture(texture, core::position2d<s32>(0,0)); 

                Material.setTexture(0, texture); 
            } 
        } 


        Size = size; 
        Rotation = 0.f; 

        Vertices[0].TCoords.set(1.f, 0.f); 
        Vertices[1].TCoords.set(1.f, 1.f); 
        Vertices[2].TCoords.set(0.f, 1.f); 
        Vertices[3].TCoords.set(0.f, 0.f); 
    } 

    virtual void OnRegisterSceneNode() 
    { 
        if (IsVisible) 
            SceneManager->registerNodeForRendering(this); 

        ISceneNode::OnRegisterSceneNode(); 
    } 

    virtual void render() 
    { 
        IVideoDriver* driver = SceneManager->getVideoDriver(); 
        ICameraSceneNode* camera = SceneManager->getActiveCamera(); 

        vector3df cameraView = camera->getTarget() - camera->getAbsolutePosition(); 
        cameraView.normalize(); 

        vector3df up = camera->getUpVector(); 
        up.normalize(); 

        quaternion quat; 
        quat.fromAngleAxis(Rotation * DEGTORAD, cameraView); 

        matrix4 const rotationMatrix = quat.getMatrix(); 
        rotationMatrix.transformVect(up); 

        vector3df horizontal = cameraView.crossProduct(up).normalize(); 
        vector3df const vertical = cameraView.crossProduct(horizontal).normalize() * Size.Height * 0.5f; 
        horizontal *= Size.Width * 0.5f; 

        for (s32 i=0; i<4; ++i) 
            Vertices[i].Normal = -cameraView; 

        vector3df const myPosition = AbsoluteTransformation.getTranslation(); 
        Vertices[0].Pos = myPosition - horizontal - vertical; 
        Vertices[1].Pos = myPosition - horizontal + vertical; 
        Vertices[2].Pos = myPosition + horizontal + vertical; 
        Vertices[3].Pos = myPosition + horizontal - vertical; 

        static u16 const indices[] = { 0, 1, 2, 0, 2, 3 }; 

        driver->setMaterial(Material); 
        driver->setTransform(ETS_WORLD, IdentityMatrix); 
        driver->drawIndexedTriangleList(Vertices, 4, indices, 2); 
    } 

    const aabbox3d<f32>& getBoundingBox() const { return Box; } 

    u32 getMaterialCount() const { return 1; } 

    SMaterial& getMaterial(u32 i) { return Material; } 

    void setSpriteRotation(f32 rotation) 
    { 
        Rotation = rotation; 
        while(Rotation >= 360.f) 
            Rotation -= 360.f; 
        while(Rotation < 0.f) 
            Rotation += 360.f; 
    } 

    f32 getSpriteRotation(void) const { return Rotation; } 

    dimension2df const & getSize(void) const { return Size; } 

    void setSize(dimension2df const & size) { Size = size; } 

};