Jump to content

View more

Image of the Day

#ld38 #screenshotsaturday Mimosa Fizz action gif #2 https://t.co/TUzdppvfUL
IOTD | Top Screenshots

The latest, straight to your Inbox.

Subscribe to GameDev.net Direct to receive the latest updates and exclusive content.


Sign up now

Irrlicht and render a polygon with a texture

4: Adsense

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   

1621
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.





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.