Jump to content

  • Log In with Google      Sign In   
  • Create Account

Irrlicht and render a polygon with a texture


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
No replies to this topic

#1 MARS_999   Members   -  Reputation: 1297

Like
0Likes
Like

Posted 04 June 2013 - 03:49 PM

I am trying to render a arbitrary shape that starts out as a triangle and grows into a circle. I am not getting my math and/or Irrlicht's rendering calls correct to be able to do this.

 

Here is the code, hope it helps someone to help me solve my problem...

 

class ShapeAbstract
{
private:
    std::vector<irr::video::S3DVertex> vertex;
    std::vector<irr::u16> index;
    
public:
    ShapeAbstract(unsigned int level = 3,
                  const irr::video::SColor& color = irr::video::SColor(255, 255, 255, 255))
    {
        CalculateVertices(level, color);
        CalculateIndices(level);
    }
    ~ShapeAbstract(){}
    inline void Draw(NX::Object* obj,
                     irr::video::IVideoDriver *driver, irr::video::ITexture* texture,
                     irr::core::rect<irr::s32> sourceRect,
                     irr::core::position2d<irr::s32> position,
                     irr::core::position2d<irr::s32> rotationPoint,
                     irr::f32 rotation,
                     bool useAlphaChannel,
                     const irr::video::SColor& color)
    {
        irr::core::matrix4 oldProjMat = driver->getTransform(irr::video::ETS_PROJECTION);
        driver->setTransform(irr::video::ETS_PROJECTION, irr::core::matrix4());
        irr::core::matrix4 oldViewMat = driver->getTransform(irr::video::ETS_VIEW);
        driver->setTransform(irr::video::ETS_VIEW, irr::core::matrix4());

        irr::core::vector2df corner[4];
        corner[0] = irr::core::vector2df((irr::f32)position.X, (irr::f32)position.Y);
        corner[1] = irr::core::vector2df((irr::f32)position.X + sourceRect.getWidth(), (irr::f32)position.Y);
        corner[2] = irr::core::vector2df((irr::f32)position.X, (irr::f32)position.Y + sourceRect.getHeight());
        corner[3] = irr::core::vector2df((irr::f32)position.X + sourceRect.getWidth(), (irr::f32)position.Y + sourceRect.getHeight());

        for(int x = 0; x < 4; ++x)
            corner[x].rotateBy(rotation, irr::core::vector2df((irr::f32)rotationPoint.X, (irr::f32)rotationPoint.Y));

        irr::core::vector2df uvCorner[4];    
        uvCorner[0] = irr::core::vector2df(0,0);
        uvCorner[1] = irr::core::vector2df(0,1);
        uvCorner[2] = irr::core::vector2df(1,0);
        uvCorner[3] = irr::core::vector2df(1,1);
                
        //if(obj->GetLevel() < 12)
        //    CalculateVertices(obj->GetLevel()+1, color);

        //static irr::u16 indices[6] = {0, 1, 2, 3 ,2 ,1};
                
        //Using indices like this: 0 1 2   0 2 3   0 3 4  ... for a fan list
        
         /*
        std::vector<irr::u16> indices;
        for(int x = 0; x < obj->GetLevel(); ++x)
        {
            indices.push_back(x);
        }
        */
        
        //irr::core::matrix4 translate;
        //irr::core::matrix4 rot;
        //rot.setRotationDegrees(irr::core::vector3df(0.0f, 0.0f, 60.0f));
        //translate.setTranslation(irr::core::vector3df(screenPosX, screenPosY, 1));
        //translate.transformVect(vertex[x].Pos);
        //rot.rotateVect(v);
        float screenWidth  = (irr::f32)driver->getScreenSize().Width;
        float screenHeight = (irr::f32)driver->getScreenSize().Height;
        for(int x = 0; x < vertex.size(); ++x)
        {
            float screenPosX  = ((corner[x].X/screenWidth) -0.5f)* 2.0f;
            float screenPosY  = ((corner[x].Y/screenHeight)-0.5f)*-2.0f;
            //vertex[x].Pos     = irr::core::vector3df(screenPosX, screenPosY, 1);    
            //think I need to do a translation of this point from vertex.pos from the screenPoX, screenPosY, 1 point
            vertex[x].TCoords = uvCorner[x];
            vertex[x].Color   = color;            
        }

        irr::video::SMaterial material;
        material.Lighting     = false;
        material.ZWriteEnable = false;
        material.UseMipMaps   = true;
        material.AntiAliasing = irr::video::EAAM_FULL_BASIC;
        material.TextureLayer[0].Texture           = texture;
        material.TextureLayer[0].AnisotropicFilter = 16;
        material.TextureLayer[0].TrilinearFilter   = true;
        material.TextureLayer[0].TextureWrapU      = irr::video::ETC_CLAMP;
        material.TextureLayer[0].TextureWrapV      = irr::video::ETC_CLAMP;
    
        if(useAlphaChannel)
            material.MaterialType = irr::video::EMT_TRANSPARENT_ALPHA_CHANNEL;
        else
            material.MaterialType = irr::video::EMT_SOLID;

        driver->setMaterial(material);
        driver->drawIndexedTriangleFan(&vertex[0],vertex.size(),
                                       &index[0], index.size() - 2);
        /*driver->drawIndexedTriangleList(&vertex[0],vertex.size(),
                                          &index[0], index.size() / 3);
        */
        driver->setTransform(irr::video::ETS_PROJECTION, oldProjMat);
        driver->setTransform(irr::video::ETS_VIEW, oldViewMat);
    }
    inline void CalculateVertices(unsigned int sides, const irr::video::SColor& color)
    {
        //X=SIN(RADIANS(angle))* radius
        //Y=COS(RADIANS(angle))* radius
        //float angle  = 180.0f - (360.0f/float(level));
        vertex.clear();
        //vertex.push_back(irr::video::S3DVertex(.5f, .5f, 1.0f, 0.0f, 0.0f, 0.0f, color, 0.0f, 0.0f));
        unsigned int angle = 360 / sides;
        for(unsigned int i = 0.0f; i < 360.0f; i+=angle)
        {
            irr::video::S3DVertex v(sinf(irr::core::degToRad(float(i))),
                                    cosf(irr::core::degToRad(float(i))),
                                    0.0f,
                                    0.0f, 0.0f, 0.0f,
                                    color,
                                    0.0f, 0.0f);
            vertex.push_back(v);
        }
    }
    inline void CalculateIndices(unsigned int sides)
    {
        index.clear();
        for(unsigned int n = 2; n < sides; ++n)
        {
            index.push_back(0);
            index.push_back(n - 1);
            index.push_back(n);
        }
    }
};

Edited by MARS_999, 04 June 2013 - 03:50 PM.


Sponsor:



Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS