Chodzenie

[Micja]

Witam!!!

 

Pamiętam, że kiedyś w przykładach na GMCla było takie coś jak chodzenie w stylu gta . Jako że aktualnie nie posiadam GM prosiłbym was o algorytm takiego ruchu. Może być kawałek kody ale i sam algorytm.

 

Prosze o pomoc.

Pozdrawiam.

[PsichiX]

toz to proscizna.

 

if(keyboard_check(vk_left))direction+=10
if(keyboard_check(vk_right))direction-=10
if(keyboard_check(vk_up))
{
x+=lengthdir_x(6,direction)
y+=lengthdir_y(6,direction)
}
if(keyboard_check(vk_down))
{
x-=lengthdir_x(4,direction)
y-=lengthdir_y(4,direction)
}
image_alpha=direction

 

PS. Nie ten dzial

[KoRn]

FAQ się kłania...

[Micja]

PS. Nie ten dzial

 

Chodziłó mi o przykład w c++ i dlatego...

[blackmaul]

Chcesz kod do czego? Do dowolnej biblioteki graficznej? Poza tym, co z tego, że taki przykład był, skoro on wykorzystywał GM a nie C++? ;x

[Will]

hmm.. najpierw musisz stworzyć kamerę.. Czyli macieże lub wektory.. Tworzymy macież widoku, projekcji, obsługa klawiatury dla poruszania + myszka do obrotów. Albo masz tu mój kod dołóż sobie obsługę Inputa i lux tylko w DirectX to jest ;)

#ifndef CAMERA_H
#define CAMERA_H

#include <d3dx9.h>
#include"DInput.h"
#include<iostream>
#include<sstream>
using namespace std;

class Camera
{
public:
    Camera();
    D3DXVECTOR3 mPos;
    
    const D3DXMATRIX& view();
    const D3DXMATRIX& proj();
    const D3DXMATRIX& viewProj();

    float fov();
    float aspect();
    float nearZ();
    float farZ();

    
    D3DXVECTOR3& pos();

    void lookAt(D3DXVECTOR3& pos, D3DXVECTOR3& target, D3DXVECTOR3& up);
    void setLens(float fov, float aspect, float nearZ, float farZ);
     
     void SetFontforPos(IDirect3DDevice9* Device);
     void DrawPos(int a,int b,float x,float y,float z);
    
    virtual void update(float dt)=0;

protected:
    void buildView();

protected:
    D3DXMATRIX mView;
    D3DXMATRIX mProj;
    D3DXMATRIX mViewProj;

    float mFOV;
    float mAspect;
    float mNearZ;
    float mFarZ;
    ID3DXFont* m_FontPos;
    stringstream pozycja;
    
    
    
    D3DXVECTOR3 mRight;
    D3DXVECTOR3 mUp;
    D3DXVECTOR3 mLook;
    float Y;
    // Speed (m/s) or (rad/s)
    float mLinearSpeed;
    float mAngularSpeed;
};

class FreeCamera : public Camera
{
public:
    
   
    void update(float dt);

};


#include "Camera.h"
#include "will.h"


Camera::Camera()
{ 
    Y=0;
    
    D3DXMatrixIdentity(&mView);     //1 0 0 0
    D3DXMatrixIdentity(&mProj);     //0 1 0 0
    D3DXMatrixIdentity(&mViewProj); //0 0 1 0
                                    //0 0 0 1 
    mFOV    = 0.0f;
    mAspect = 0.0f;
    mNearZ  = 0.0f;
    mFarZ   = 0.0f;

    mPos   = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
    mRight = D3DXVECTOR3(1.0f, 0.0f, 0.0f); //pozycja osi x
    mUp    = D3DXVECTOR3(0.0f, 1.0f, 0.0f); // pozycja osi y
    mLook  = D3DXVECTOR3(0.0f, 0.0f, 1.0f); // pozycja osi z

    mLinearSpeed  = 10.0f;
    mAngularSpeed = 1.0f;
}

const D3DXMATRIX& Camera::view()
{
    return mView;
}

const D3DXMATRIX& Camera::proj()
{
    return mProj;
}

const D3DXMATRIX& Camera::viewProj()
{
    return mViewProj;
}

float Camera::fov()
{
    return mFOV;
}

float Camera::aspect()
{
    return mAspect;
}

float Camera::nearZ()
{
    return mNearZ;
}    

float Camera::farZ()
{
    return mFarZ;
}

D3DXVECTOR3& Camera::pos()
{
    return mPos;
}

void Camera::lookAt(D3DXVECTOR3& pos, D3DXVECTOR3& target, D3DXVECTOR3& up)
{
    
    D3DXVECTOR3 L = target - pos; 
    D3DXVec3Normalize(&L, &L);  

    D3DXVECTOR3 R;
    
    D3DXVec3Cross(&R, &up, &L); 
    

    D3DXVECTOR3 U;
    
    D3DXVec3Cross(&U, &L, &R);
    

    mPos   = pos;
    mRight = R;
    mUp    = U;
    mLook  = L;
}

void Camera::setLens(float fov, float aspect, float nearZ, float farZ)
{
    mFOV    = fov;
    mAspect = aspect;
    mNearZ  = nearZ;
    mFarZ   = farZ;

    D3DXMatrixPerspectiveFovLH(&mProj, fov, aspect, nearZ, farZ);
    
}

void Camera::buildView()
{
    D3DXVECTOR3& P = mPos;
    D3DXVECTOR3& L = mLook;
    D3DXVECTOR3& U = mUp;
    D3DXVECTOR3& R = mRight;

    D3DXVec3Normalize(&L, &L);
    
    D3DXVec3Cross(&U, &L, &R);
    D3DXVec3Normalize(&U, &U);
   
    D3DXVec3Cross(&R, &U, &L);
    D3DXVec3Normalize(&R, &R);
    
    float x = -D3DXVec3Dot(&P, &R);
    float y = -D3DXVec3Dot(&P, &U);
    float z = -D3DXVec3Dot(&P, &L);

    mView(0,0) = R.x; 
    mView(1,0) = R.y; 
    mView(2,0) = R.z; 
    mView(3,0) = x;   

    mView(0,1) = U.x;
    mView(1,1) = U.y;
    mView(2,1) = U.z;
    mView(3,1) = y;  

    mView(0,2) = L.x; 
    mView(1,2) = L.y; 
    mView(2,2) = L.z; 
    mView(3,2) = z;   

    mView(0,3) = 0.0f;
    mView(1,3) = 0.0f;
    mView(2,3) = 0.0f;
    mView(3,3) = 1.0f;
}


void FreeCamera::update(float dt)
{
    // chodzenie do przodu i do tylu
    if( will::gInput->keyDown(DIK_W) )
        mPos += mLook * mLinearSpeed * dt;
    if(will::gInput->keyDown(DIK_S) )
        mPos -= mLook * mLinearSpeed * dt;

    // Strefujem lewo i w prawo
    if( will::gInput->keyDown(DIK_D) )
        mPos += mRight * mLinearSpeed * dt;
    if( will::gInput->keyDown(DIK_A) )
        mPos -= mRight * mLinearSpeed * dt;
     
    
    float deltaX = (float)will::gInput->mouseDX() * 0.005f;
    float deltaY = (float)will::gInput->mouseDY() * 0.005f;

    // rotacja wokol X 

        D3DXMATRIX R;
        
           Y+=deltaY;
        if(Y>2.0f)
        {
            Y=2.0f;
            deltaY=0;
        }
        else if(Y<-2.0f)
        {
            Y=-2.0f;
            deltaY=0;
        }
        
    D3DXMatrixRotationAxis(&R, &mRight, deltaY);    

    D3DXVec3TransformCoord(&mLook, &mLook, &R);
    D3DXVec3TransformCoord(&mUp, &mUp, &R);

        
    

    // rotacja wokol y
    
    
    D3DXMatrixRotationY(&R, deltaX);
    D3DXVec3TransformCoord(&mLook, &mLook, &R);
    D3DXVec3TransformCoord(&mRight, &mRight, &R);


    buildView();

    mViewProj = mView * mProj;
}


void Camera::SetFontforPos(IDirect3DDevice9* Device)
{
    D3DXFONT_DESC  lf;
    ZeroMemory(&lf, sizeof(lf));

    lf.Height         = 15;    /
    lf.Width          = 6;    
    lf.MipLevels     = 0;        
      
    lf.Weight         = 500;   
    lf.Italic         = false;   
     
    lf.CharSet        = DEFAULT_CHARSET;
    lf.OutputPrecision   = 0;              
             
    lf.Quality        = 0;           
    lf.PitchAndFamily = 0;           
    strcpy(lf.FaceName, "Times New Roman"); // font style

    //
    // Tworzymy object font
    //

    if(FAILED(D3DXCreateFontIndirect(Device, &lf, &m_FontPos)))
    {
        ::MessageBox(0, "D3DXCreateFontIndirect() - FAILED for Camera pos", 0, 0);
        ::PostQuitMessage(0);
    }
}
//a teraz rysujemy pozycje
void Camera::DrawPos(int a,int b,float x,float y,float z)
{
    
    
    
    RECT rect = {0, 0, a, b};
        
            char buf[256];
    _snprintf(buf, 256, "Position: (%.2f, %.2f, %.2f)", 
      x, y, 
      z);

    
    m_FontPos->DrawTextA(0,buf,-1,&rect,DT_TOP | DT_LEFT,D3DCOLOR_XRGB(0,0,0));
}