public void DrawAnimationSprite(SpriteBatch spritebatch)
         {
             int frameWight = spriteTextureRun.Width / frameCount;
             Rectangle rect = new Rectangle(frameWight * frame, 0, frameWight, spriteTextureRun.Height);
             SpriteEffects effect = SpriteEffects.None;

             spritebatch.Draw(spriteTextureRun, spritePosition, rect, Color.White);

             if (!isRunRight)
             {
                 spritebatch.Draw(spriteTextureRun, spritePosition, rect, Color.White, 0, Vector2.Zero, effect, 0);
             }
             else
             {
                 spritebatch.Draw(spriteTextureRun, spritePosition, rect, Color.White);
             }
         }

namespace Game
{
     class Sprite
     {
         public Texture2D spriteTexture;
         public Vector2 spritePosition;

         private int frameCount;
         private double timeFrame;
         private int frame;
         private double totalElapsed;

         public Sprite(int frameCounts, int framesPerSec)
         {
             frameCount = frameCounts;
             timeFrame = (float)1 / framesPerSec;
             frame = 0;
             totalElapsed = 0;
         }

         public void UpdateFarme(double elapsed)
         {
             totalElapsed += elapsed;
             if (totalElapsed > elapsed)
             {
                 frame++;
                 frame = frame % (frameCount - 1);
                 totalElapsed -= timeFrame;
             }
         }

         public void Load(ContentManager content, String stringTexture)
         {
             spriteTexture = content.Load<Texture2D>(stringTexture);
         }

         public void Draw(SpriteBatch spriteBatch)
         {
             spriteBatch.Draw(spriteTexture, spritePosition, Color.White);
         }

         public void DrawAnimationSprite(SpriteBatch spritebatch)
         {
             int frameWight = spriteTexture.Width / frameCount;
             Rectangle rect = new Rectangle(frameWight * frame, 0, frameWight, spriteTexture.Height);
             spritebatch.Draw(spriteTexture, spritePosition, rect, Color.White);
         }
     }
}

namespace Game
{
     public class Game1 : Microsoft.Xna.Framework.Game
     {
         GraphicsDeviceManager graphics;
         SpriteBatch spriteBatch;

         Sprite sprite;

         public Game1()
         {
             graphics = new GraphicsDeviceManager(this);
             Content.RootDirectory = "Content";

             graphics.PreferredBackBufferHeight = 600;
             graphics.PreferredBackBufferWidth = 800;

             sprite = new Sprite(2, 1);
         }

         protected override void Initialize()
         {
             sprite.spritePosition = new Vector2(200,200);

             base.Initialize();
         }

         protected override void LoadContent()
         {
             spriteBatch = new SpriteBatch(GraphicsDevice);
             sprite.Load(Content,"Folder\\hero_step");
         }

         protected override void UnloadContent()
         {
         }

         protected override void Update(GameTime gameTime)
         {
             if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                 this.Exit();

             double elapsed = gameTime.ElapsedGameTime.TotalSeconds;
             sprite.UpdateFarme(elapsed);

             base.Update(gameTime);
         }

         protected override void Draw(GameTime gameTime)
         {
             GraphicsDevice.Clear(Color.CornflowerBlue);

             spriteBatch.Begin();
             sprite.DrawAnimationSprite(spriteBatch);
             spriteBatch.End();

             base.Draw(gameTime);
         }
     }
}

#include <Windows.h>
#include <d3d9.h>
#include <d3dx9.h>
#include <d3dx9math.h>
#include <MMSystem.h>

LPDIRECT3D9 pDirect3D = NULL;
LPDIRECT3DDEVICE9 pDirectDevice = NULL;
LPDIRECT3DVERTEXBUFFER9 pBufferVershin = NULL;
LPDIRECT3DINDEXBUFFER9 pBufferIndex = NULL;

struct CUSTOMVERTEX
{
  float X, Y, Z;
  DWORD color;
};
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE)

HRESULT InitialDirect3D(HWND hwnd)
{
  //if(NULL == (pDirect3D = Direct3DCreate9(D3D_SDK_VERSION)))
  //    return E_FAIL;

  D3DDISPLAYMODE Display;
  //if(FAILED(pDirect3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &Display)))
  //    return E_FAIL;

  D3DPRESENT_PARAMETERS Direct3DParametr;
  ZeroMemory(&Direct3DParametr,sizeof(Direct3DParametr));
  Direct3DParametr.Windowed = true;
  Direct3DParametr.SwapEffect = D3DSWAPEFFECT_DISCARD;
  Direct3DParametr.BackBufferFormat = Display.Format;
  //if(FAILED(pDirect3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hwnd,D3DCREATE_SOFTWARE_VERTEXPROCESSING,&Direct3DParametr,&pDirectDevice)))
  //    return E_FAIL;

  pDirectDevice->SetRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
  pDirectDevice->SetRenderState(D3DRS_LIGHTING,false);
  return S_OK;
}

HRESULT InitialObject()
{
  CUSTOMVERTEX Vershin[] =
  {
     {  1.0f,-1.0f,-1.0f, 0x00000fff, }, //А
        { -1.0f,-1.0f,-1.0f, 0x00000fff, }, //В
        { -1.0f, 1.0f,-1.0f, 0x00000fff, }, //С
     {  1.0f, 1.0f,-1.0f, 0x00000fff, }, //D

     {  1.0f,-1.0f, 1.0f, 0x00000fff, }, //A3
        { -1.0f,-1.0f, 1.0f, 0x00000fff, }, //B3
        { -1.0f, 1.0f, 1.0f, 0x00000fff, }, //C3
     {  1.0f, 1.0f, 1.0f, 0x00000fff, }, //D3

     {  1.0f,-1.0f,-1.0f, 0x00000fff, }, //A4
        {  1.0f,-1.0f, 1.0f, 0x00000fff, }, //B4
        {  1.0f, 1.0f, 1.0f, 0x00000fff, }, //C4
     {  1.0f, 1.0f,-1.0f, 0x00000fff, }, //D4

     {  1.0f, 1.0f, 1.0f, 0x00000fff, }, //A5
        { -1.0f, 1.0f, 1.0f, 0x00000fff, }, //B5
        { -1.0f, 1.0f,-1.0f, 0x00000fff, }, //C5
     {  1.0f, 1.0f,-1.0f, 0x00000fff, }, //D5
         
        {  1.0f,-1.0f, 1.0f, 0x00000fff, }, //A6
        { -1.0f,-1.0f, 1.0f, 0x00000fff, }, //B6
        { -1.0f,-1.0f,-1.0f, 0x00000fff, }, //C6
     {  1.0f,-1.0f,-1.0f, 0x00000fff, }, //D6
  };
  const unsigned short Index[] =  
  {
   0,1,2,      2,3,0,
     4,5,6,      6,7,4,
     8,9,10,     10,11,8,
  12,13,14,   14,15,12,
     16,17,18,   18,19,16,
  20,21,22,   22,23,20,
  };

  //if( FAILED( pDirectDevice->CreateVertexBuffer(36*sizeof(CUSTOMVERTEX),0,D3DFVF_CUSTOMVERTEX,D3DPOOL_DEFAULT,&pBufferVershin,NULL)))
     //    return E_FAIL;
  void* pBV;
  //if (FAILED(pBufferVershin->Lock(0,sizeof(Vershin),(void**)pBV,0)))
  //    return E_FAIL;
  memcpy(pBV,Vershin,sizeof(Vershin));
  pBufferVershin->Unlock();  
      
     pDirectDevice->CreateIndexBuffer( 36 * sizeof(Index),  
        0, D3DFMT_INDEX16, D3DPOOL_DEFAULT,&pBufferIndex, NULL);
      
     VOID* pBI;
     pBufferIndex->Lock( 0, sizeof(Index) , (void**)&pBI, 0 );
     
     memcpy( pBI, Index, sizeof(Index) );
      
     pBufferIndex->Unlock();
}

void Matrix()
{
  D3DXMATRIX MatrixWorld;
  D3DXMATRIX MatrixView;
  D3DXMATRIX MatrixProjection;

  UINT Time = timeGetTime() % 5000;
  float Angle = Time * (2.0f * D3DX_PI) / 5000.0f;
  D3DXMatrixRotationY(&MatrixWorld,Angle);
  pDirectDevice->SetTransform(D3DTS_WORLD,&MatrixWorld);

  D3DXMatrixLookAtLH(&MatrixView,&D3DXVECTOR3(0.0f,0.0f,-8.0f),&D3DXVECTOR3(0.0f,0.0f,0.0f),&D3DXVECTOR3(0.0f,1.0f,0.0f));
  pDirectDevice->SetTransform(D3DTS_VIEW,&MatrixView);

  D3DXMatrixPerspectiveFovLH(&MatrixProjection,D3DX_PI/4,1.0f,1.0,100.0f);
  pDirectDevice->SetTransform(D3DTS_PROJECTION,&MatrixProjection);
}

void RenderingDirect3D()
{
  if(pDirectDevice == NULL)
   return;
  pDirectDevice->Clear(0,NULL,D3DCLEAR_TARGET,D3DCOLOR_XRGB(225,225,50),1.0f,0);
  pDirectDevice->BeginScene();

  Matrix();

  pDirectDevice->SetStreamSource(0,pBufferVershin,0,sizeof(CUSTOMVERTEX));
  pDirectDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
     pDirectDevice->SetIndices(pBufferIndex);
  pDirectDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,0,36,0,12);
    
  pDirectDevice->EndScene();

  pDirectDevice->Present(NULL,NULL,NULL,NULL);
}

void DeleteDirect3D()
{

      if( pBufferIndex  != NULL)
         pBufferIndex->Release();  

     if( pBufferVershin  != NULL)
         pBufferVershin->Release();  

     if( pDirectDevice != NULL)  
         pDirectDevice->Release();

     if( pDirect3D != NULL)
         pDirect3D->Release();

}

LRESULT CALLBACK MainWinProc(HWND   hwnd,UINT    msg,WPARAM  wparam,LPARAM  lparam)           
{

switch(msg)
  {  
   
      case WM_DESTROY:  
   {
   DeleteDirect3D();
   PostQuitMessage(0);
   return(0);
   }  
  }  
   return DefWindowProc(hwnd, msg, wparam, lparam);
}  

int WINAPI WinMain(    HINSTANCE hinstance,
      HINSTANCE hprevinstance,
      LPSTR lpcmdline,
      int ncmdshow)
{

WNDCLASSEX windowsclass;   
HWND    hwnd;        
MSG        msg;           

windowsclass.cbSize         = sizeof(WNDCLASSEX);
windowsclass.style   = CS_DBLCLKS | CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
windowsclass.lpfnWndProc    = MainWinProc;
windowsclass.cbClsExtra  = 0;
windowsclass.cbWndExtra  = 0;
windowsclass.hInstance  = hinstance;
windowsclass.hIcon   = LoadIcon(NULL, IDI_APPLICATION);
windowsclass.hCursor  = LoadCursor(NULL, IDC_ARROW);
windowsclass.hbrBackground    = (HBRUSH)GetStockObject(GRAY_BRUSH);
windowsclass.lpszMenuName    = NULL;
windowsclass.lpszClassName    = L"WINDOWSCLASS";
windowsclass.hIconSm        = LoadIcon(NULL, IDI_APPLICATION);

if (!RegisterClassEx(&windowsclass))
  return(0);

if (!(hwnd = CreateWindowEx(NULL,              
                        L"WINDOWSCLASS",          
         L"Cube",                 
         WS_OVERLAPPEDWINDOW | WS_VISIBLE,
         300,150,                 
         500,400,                 
         NULL,                 
         NULL,                 
         hinstance,               
         NULL)))                    
return 0;
       
  if( SUCCEEDED( InitialDirect3D( hwnd ) ) )
   {  
        if( SUCCEEDED( InitialObject( ) ) )
      {
            ShowWindow( hwnd, SW_SHOWDEFAULT );
            UpdateWindow( hwnd );

               ZeroMemory( &msg, sizeof(msg));
               while( msg.message!=WM_QUIT)  
                 {
                   if(PeekMessage( &msg, NULL,0,0,PM_REMOVE ))
              {
              TranslateMessage( &msg );
                       DispatchMessage( &msg );
                    }
                   else
                   RenderingDirect3D();
                 }  
         }
   }  
    return 0;
}