수다닷컴

안녕하세요 UDP소켓 라이브러리중 콴타라이브러리로 예제실습중인데요..
클라이언트까지는 생성되서 실행되는데 서버쪽에서 RECIEVE문제인지 계속 에러나거나
에러가안나도 다이렉트 메인루프를 돌아서 실행이안되는데요..
타임델타값주고 별짓다해봐도 안되는데..
어떻게 해야 실행될지 막막합니다..
쓰레드를 써야할지도 고민인데 교수님말로는 쓰레드안써도 UDP에서 잘돌아간다고 하는데 뭐가문제일지
제발 알려주세요 ㅠ.ㅠ 손봐야할 코드있으면 좀알려주시면 정말 평생잊지 않겠습니다. ㅠ.ㅠ
고수님들 제발도와주세요 ㅠ.ㅠ다이렉트 헤더파일
#ifndef __d3dUtilityH__
#define __d3dUtilityH__
#include d3dx9.h
#include string
namespace d3d
{
bool InitD3D(
HINSTANCE hInstance, // [in] Application instance.
int width, int height, // [in] Backbuffer dimensions.
bool windowed, // [in] Windowed (true)or full screen (false).
D3DDEVTYPE deviceType, // [in] HAL or REF
IDirect3DDevice9** device);// [out]The created device.
int EnterMsgLoop(
bool (*ptr_display)(float timeDelta));
LRESULT CALLBACK WndProc(
HWND hwnd,
UINT msg,
WPARAM wParam,
LPARAM lParam);
templateclass T void Release(T t)
{
if( t )
{
t-Release();
t = 0;
}
}

templateclass T void Delete(T t)
{
if( t )
{
delete t;
t = 0;
}
}
}
#endif // __d3dUtilityH__==============================================================================================
다이렉트X 소스파일 1
#include d3dUtility.h
bool d3d::InitD3D(
HINSTANCE hInstance,
int width, int height,
bool windowed,
D3DDEVTYPE deviceType,
IDirect3DDevice9** device)
{
//
// Create the main application window.
//
WNDCLASS wc;
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = (WNDPROC)d3d::WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(0, IDI_APPLICATION);
wc.hCursor = LoadCursor(0, IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wc.lpszMenuName = 0;
wc.lpszClassName = Direct3D9App;
if( !RegisterClass(&wc) )
{
::MessageBox(0, RegisterClass() - FAILED, 0, 0);
return false;
}

HWND hwnd = 0;
hwnd = ::CreateWindow(Direct3D9App, Direct3D9App,
WS_EX_TOPMOST,
0, 0, width, height,
0 /*parent hwnd*/, 0 /* menu */, hInstance, 0 /*extra*/);
if( !hwnd )
{
::MessageBox(0, CreateWindow() - FAILED, 0, 0);
return false;
}
::ShowWindow(hwnd, SW_SHOW);
::UpdateWindow(hwnd);
//
// Init D3D:
//
HRESULT hr = 0;
// Step 1: Create the IDirect3D9 object.
IDirect3D9* d3d9 = 0;
d3d9 = Direct3DCreate9(D3D_SDK_VERSION);
if( !d3d9 )
{
::MessageBox(0, Direct3DCreate9() - FAILED, 0, 0);
return false;
}
// Step 2: Check for hardware vp.
D3DCAPS9 caps;
d3d9-GetDeviceCaps(D3DADAPTER_DEFAULT, deviceType, &caps);
int vp = 0;
if( caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT )
vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;
else
&nbnbsp;vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
// Step 3: Fill out the D3DPRESENT_PARAMETERS structure.

D3DPRESENT_PARAMETERS d3dpp;
d3dpp.BackBufferWidth = width;
d3dpp.BackBufferHeight = height;
d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
d3dpp.BackBufferCount = 1;
d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
d3dpp.MultiSampleQuality = 0;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.hDeviceWindow = hwnd;
d3dpp.Windowed = windowed;
d3dpp.EnableAutoDepthStencil = true;
d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
d3dpp.Flags = 0;
d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
// Step 4: Create the device.
hr = d3d9-CreateDevice(
D3DADAPTER_DEFAULT, // primary adapter
deviceType, // device type
hwnd, // window associated with device
vp, // vertex processing
&d3dpp, // present parameters
device); // return created device
if( FAILED(hr) )
{
// try again using a 16-bit depth buffer
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;

hr = d3d9-CreateDevice(
D3DADAPTER_DEFAULT,
deviceType,
hwnd,
vp,
&d3dpp,
device);
if( FAILED(hr) )
{
d3d9-Release(); // done with d3d9 object
::MessageBox(0, CreateDevice() - FAILED, 0, 0);
return false;
}
}
d3d9-Release(); // done with d3d9 object

return true;
}
int d3d::EnterMsgLoop( bool (*ptr_display)(float timeDelta) )
{
MSG msg;
::ZeroMemory(&msg, sizeof(MSG));
static float lastTime = (float)timeGetTime();
while(msg.message != WM_QUIT)
{
if(::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
{
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
else
{
float currTime = (float)timeGetTime();
float timeDelta = (currTime - lastTime)*0.001f;
ptr_display(timeDelta);
lastTime = currTime;
}
}
return msg.wParam;
}
==============================================================================================
다이렉트X 소스파일 2

#include d3dUtility.h
#include string.h
#include iostream
#include UdpServer.h

int udpPort = 7001;
CUDPServer server(udpPort);

/*
void parseCommandLine(int argc, char ** argv)
{
strcpy(udpIP, 127.0.0.1);// default udp serverIP is localhost
if (argc 1)
strcpy(udpIP, argv[1]);
if (argc 2)
udpPort = atoi(argv[2]);
std::cout udp client active udpIP udpPort std::endl;
}
*/
/*
int main (int argc, char** argv)
{
parseCommandLine(argc, argv);
CUDPClient client(udpIP, udpPort);
while (!GetAsyncKeyState(VK_ESCAPE)) {
sprintf(sendBuf,COUNT %d\n,count++);
client.Send(sendBuf);
std::cout send data via udp std::endl;
QUANTAsleep(5);
}
return 0;
}
*/
//
// Globals
//
IDirect3DDevice9* Device = 0;
const int Width = 640;
const int Height = 480;
int mod =0;
bool qumod = false;
// Mesh interface that will store the teapot data and contains
// ma method to render the teapot data.
ID3DXMesh* Teapot = 0;
ID3DXMesh* a1 = 0;
ID3DXMesh* a2 = 0;
float ra = 4.0f;
float ra1 = -4.0f;

//
// Framework Functions
//
bool Setup()
{
//
// Create the teapot geometry.
//
//D3DXCreateTeapot(Device, &Teapot, 0);
D3DXCreateSphere(Device,0.5f,10,10,&a1, 0);
D3DXCreateSphere(Device,0.5f,10,10,&a2, 0);

//
// Position and aim the camera.
//
D3DXVECTOR3 position(0.0f, 0.0f, -3.0f);
D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
D3DXMATRIX V;
D3DXMatrixLookAtLH(&V, &position, &target, &up);
Device-SetTransform(D3DTS_VIEW, &V);
//
// Set projection matrix.
//
D3DXMATRIX proj;
D3DXMatrixPerspectiveFovLH(
&proj,
D3DX_PI * 0.5f, // 90 - degree
(float)Width / (float)Height,
1.0f,
1000.0f);
Device-SetTransform(D3DTS_PROJECTION, &proj);
//
// Switch to wireframe mode.
//
Device-SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);return true;
}
void Cleanup()
{
//d3d::ReleaseID3DXMesh*(Teapot);
d3d::ReleaseID3DXMesh*(a1);
d3d::ReleaseID3DXMesh*(a2);
}
bool Display(float timeDelta)
{
if( Device )
{
//
// Spin the teapot:
//
D3DXMATRIX Ry;
//static float y = 0.0f;
//D3DXMatrixRotationY(&Ry, y);
D3DXMatrixRotationY(&Ry, 0);
/*
y += timeDelta;
if(y = 6.28f)
y = 0.0f;
*/
Device-SetTransform(D3DTS_WORLD, &Ry);
//
// Draw the Scene:
//
Device-Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0);
Device-BeginScene();// Draw teapot using DrawSubset method with 0 as the argument.
D3DXMATRIX sphereMatrix;
D3DXMatrixTranslation(&sphereMatrix, ra, -2.0f, 6.0f);
Device-SetTransform(D3DTS_WORLD, &sphereMatrix);
a1-DrawSubset(0);
//a1-DrawSubset(0);
D3DXMATRIX sphereMatrix2;
D3DXMatrixTranslation(&sphereMatrix2, ra1, -2.0f, 6.0f);
Device-SetTransform(D3DTS_WORLD, &sphereMatrix2);
a2-DrawSubset(0);
//a1-DrawSubset(0);Device-EndScene();
Device-Present(0, 0, 0, 0);

int temp = timeDelta*1000;
if(temp%5000 == 0)
{
OutputDebugString(시작);
if(qumod == true)
{
&server.Receive();
}
OutputDebugString(끝);
}

}
return true;
}

//
// WndProc
//
LRESULT CALLBACK d3d::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch( msg )
{
case WM_DESTROY:
::PostQuitMessage(0);
break;

case WM_KEYDOWN:
if( wParam == VK_ESCAPE )
::DestroyWindow(hwnd);
/******************/
//F1키가 눌렸을때 변화..

if(wParam == VK_F1)
{
if(mod == 0)
{
::Device-SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
mod = 1;
}
else if(mod == 1)
{
::Device-SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
mod = 0;
}
/***********************/
}

else if(wParam == VK_F2)
{
OutputDebugString(시작);

server.Receive();
OutputDebugString(끝);
}
break;}
return ::DefWindowProc(hwnd, msg, wParam, lParam);
}
//
// WinMain
//
int WINAPI WinMain(HINSTANCE hinstance,
HINSTANCE prevInstance,
PSTR cmdLine,
int showCmd)
{
if(!d3d::InitD3D(hinstance,
Width, Height, true, D3DDEVTYPE_HAL, &Device))
{
::MessageBox(0, InitD3D() - FAILED, 0, 0);
return 0;
}

if(!Setup())
{
::MessageBox(0, Setup() - FAILED, 0, 0);
return 0;
}
//server.Receive();
d3d::EnterMsgLoop( Display );
Cleanup();
Device-Release();
return 0;
}
==============================================================================================
UDP서버 헤더파일
#ifndef __UDP_SERVER_H__
#define __UDP_SERVER_H__
#include QUANTA/QUANTAinit.hxx
#include QUANTA/QUANTAnet_udp_c.hxx
#include QUANTA/QUANTAts_thread_c.hxx
#define MAXSIZE 256
#define BUNCHOFCLIENT 5
class CUDPServer
{
public:
CUDPServer(int port=7001);
~CUDPServer();
void CheckClient(QUANTAnet_udp_c *mUDPSocket);
void ReplyToClients();
void Receive();
protected:
int m_NumOfClients;
QUANTAnet_udp_c * m_UDPSocket;
QUANTAnet_udp_c * m_BunchSocket[BUNCHOFCLIENT];
};
#endif
==============================================================================================
UDP서버 소스파일

#include UdpServer.h
CUDPServer::CUDPServer(int port)
{
QUANTAinit();
m_UDPSocket = new QUANTAnet_udp_c;
m_UDPSocket-init(port);
m_UDPSocket-makeNonBlocking();
m_NumOfClients=0;
}
CUDPServer::~CUDPServer()
{
if (m_UDPSocket)
delete m_UDPSocket;
m_UDPSocket = NULL;
}
void CUDPServer::CheckClient(QUANTAnet_udp_c *m_UDPSocket)
{
QUANTAnet_udp_c *eachClient;
for (int i = 0; i m_NumOfClients; i++)
{
eachClient = m_BunchSocket[i];
if ((eachClient-getSendIP() == m_UDPSocket-getReceiveIP()) &&
(eachClient-getSendPort() == m_UDPSocket-getReceivePort())) return;
}
printf(NEW CLIENT\n\n);
m_BunchSocket[m_NumOfClients] = m_UDPSocket-clone();
m_BunchSocket[m_NumOfClients]-copyReceiveAddressToSendAddress();
m_NumOfClients++;
}
void CUDPServer::ReplyToClients()
{
static int ok = 0; ok++;
char mesg[256];
for(int i = 0 ; im_NumOfClients; i++)
{
sprintf(mesg,HOWDY CLIENT# %d\tTOTAL CLIENTS: %d MESSAGE: %d\n, i, m_NumOfClients, ok);
m_BunchSocket[i]-send(mesg, strlen(mesg)+1,QUANTAnet_udp_c::NON_BLOCKING);
}
}
void CUDPServer::Receive()
{
char recvline[MAXSIZE];
while(1) {
if (m_UDPSocket-receive(recvline, MAXSIZE,QUANTAnet_udp_c::BLOCKING) 0) {
printf(RECEIVED: %s,recvline);
}
CheckClient(m_UDPSocket);
ReplyToClients();
}
}

신청하기