2009년 11월 26일 목요일

color class

#ifndef Color_h__
#define Color_h__

class Color
{
public:
float r, g, b;

Color (float fR = 0.0f, float fG = 0.0f, float fB = 0.0f);

Color& operator= (float fScalar);
bool operator== (const Color& c) const;
bool operator!= (const Color& c) const { return !(*this == c); }

Color operator+ (const Color& c) const;
Color operator- (const Color& c) const;
Color operator* (float fScalar) const;
Color operator* (const Color& c) const;
Color operator/ (float fScalar) const;
Color operator/ (const Color& c) const;
Color operator- () const;
friend Color operator* (float fScalar, const Color& c);

Color& operator+= (const Color& c);
Color& operator-= (const Color& c);
Color& operator*= (float fScalar);
Color& operator*= (const Color& c);
Color& operator/= (float fScalar);
Color& operator/= (const Color& c);

static const Color WHITE; // (1,1,1)
static const Color BLACK; // (0,0,0)
};

class ColorA
{
public:
float r, g, b, a;

ColorA (float fR = 0.0f, float fG = 0.0f,
float fB = 0.0f, float fA = 0.0f);
ColorA (unsigned int iR , unsigned int iG,
unsigned int iB , unsigned int iA );

//unsigned int operator()(const GpColorA& c);
ColorA& operator= (float fScalar);
ColorA& operator= (const ColorA& c);
ColorA& operator= (const ColorA* c);
bool operator== (const ColorA& c) const;
bool operator!= (const ColorA& c) const { return !(*this == c); }

ColorA operator+ (const ColorA& c) const;
ColorA operator- (const ColorA& c) const;
ColorA operator* (float fScalar) const;
ColorA operator* (const ColorA& c) const;
ColorA operator/ (float fScalar) const;
ColorA operator/ (const ColorA& c) const;
ColorA operator- () const;
friend ColorA operator* (float fScalar, const ColorA& c);

ColorA& operator+= (const ColorA& c);
ColorA& operator-= (const ColorA& c);
ColorA& operator*= (float fScalar);
ColorA& operator*= (const ColorA& c);
ColorA& operator/= (float fScalar);
ColorA& operator/= (const ColorA& c);

static const ColorA WHITE;  // (1,1,1,1)
static const ColorA BLACK;  // (0,0,0,1)
static unsigned int GetD3DColor(const ColorA& kColor);


} ;


#include "Color.inl"

#endif // Color_h__


vector2D

/********************************************************************
created: 2009/05/11
created: 11:5:2009   5:34
filename: c:\Documents and Settings\심지현\My Documents\Visual Studio 2005\Projects\DarkKnight\DarkKnight\vector2d.h
file path: c:\Documents and Settings\심지현\My Documents\Visual Studio 2005\Projects\DarkKnight\DarkKnight
file base: vector2d
file ext: h
author: JIHYUN SIM

purpose:
*********************************************************************/

#ifndef VECTOR2D_H
#define VECTOR2D_H

class VECTOR2D
{
public:
FLOAT x,y;
VECTOR2D():x(0),y(0){}
VECTOR2D(FLOAT x,FLOAT y)
{
this->x=x;
this->y=y;
}

const float GetMagnitude() const;
const float GetDistance(VECTOR2D& v) const;

VECTOR2D operator = (const VECTOR2D& v);
VECTOR2D operator = (const FLOAT& v);
VECTOR2D operator += (const VECTOR2D& v);
VECTOR2D operator -= (const VECTOR2D& v);
VECTOR2D operator *= (const VECTOR2D& v);
VECTOR2D operator *= (const float f);
VECTOR2D operator /= (const VECTOR2D& v);
VECTOR2D operator /= (const float f);

bool operator == (const VECTOR2D& v) const;
bool operator != (const VECTOR2D& v) const;

protected:
private:
};

inline const float VECTOR2D::GetMagnitude() const {
return static_cast(sqrt(x*x + y*y));
}

inline const float VECTOR2D::GetDistance(VECTOR2D& v) const {
VECTOR2D tmp = *this;
tmp -= v;
return tmp.GetMagnitude();
}




inline VECTOR2D VECTOR2D::operator = (const VECTOR2D& v) {
x = v.x; y = v.y;
return *this;
}

inline VECTOR2D VECTOR2D::operator = (const FLOAT& v) {
x = v; y = v;
return *this;
}
inline VECTOR2D VECTOR2D::operator += (const VECTOR2D& v) {
x += v.x; y += v.y;
return *this;
}
inline VECTOR2D VECTOR2D::operator -= (const VECTOR2D& v) {
x -= v.x; y -= v.y;
return *this;
}
inline VECTOR2D VECTOR2D::operator *= (const VECTOR2D& v) {
x *= v.x; y *= v.y;
return *this;
}
inline VECTOR2D VECTOR2D::operator *= (const float f) {
x *= f; y *= f;
return *this;
}
inline VECTOR2D VECTOR2D::operator /= (const VECTOR2D& v) {
x /= v.x; y /= v.y;
return *this;
}
inline VECTOR2D VECTOR2D::operator /= (const float f) {
x /= f; y /= f;
return *this;
}

inline bool VECTOR2D::operator == (const VECTOR2D& v) const {
if(x != v.x) {
return false;
} else {
return y == v.y;
}
}
inline bool VECTOR2D::operator != (const VECTOR2D& v) const {
if(x != v.x) {
return true;
} else {
return y != v.y;
}
}

#endif

mysql connect cpp

#ifndef CMySql_h__
#define CMySql_h__

#define WIN32_LEAN_AND_MEAN //for winsock2.h

#include '' 
#include "mysql.h"

#include ''
#include ''

#pragma comment(lib, "libmySQL.lib")
#pragma comment(lib, "ws2_32.lib")


#define DB_HOST  "localhost"
#define DB_USER  "jihyunsim"
#define DB_PWD   "password"
#define DB_NAME  "database"
#define CMYSQL   CMySql::Get()

class CMySql
{
public:
CMySql();
~CMySql();

bool Init(const char* _host,const char* _user,const char* _pwd,const char* _schema);
static CMySql* Get(){return &ms_cMySql;}

int InsertRecord(const char* _table, const char* _field,const char* _value);
int Select(void* _data,const char* _query);
int ExecuteQueryString(const char*);
MYSQL_RES* GetResult();
void       FreeResult(MYSQL_RES* );

protected:

private:
MYSQL * m_psConnection;
MYSQL m_sConn;
bool  m_bConnected;
static CMySql ms_cMySql;
};

#endif // CMySql_h__


CMySql.cpp

#include "Application.h"
#include "CMySql.h"

CMySql CMySql::ms_cMySql;

CMySql::CMySql():m_psConnection(NULL),m_bConnected(false)
{
mysql_init(&m_sConn);

Init(DB_HOST,DB_USER,DB_PWD,DB_NAME);
}

CMySql::~CMySql()
{
if(m_psConnection!=NULL)
{
mysql_close(m_psConnection);
Log("------------------------------------------------------------\n");
Log(" * Mysql closed \n");
Log("------------------------------------------------------------\n");
}
}

bool CMySql::Init( const char* _host,const char* _user,const char* _pwd,const char* _schema )
{
// DB 연결
m_psConnection = mysql_real_connect(&m_sConn, _host,
_user, _pwd,_schema, 3306,(char *)NULL, 0);
if(m_psConnection==NULL)
{
Log(" * Mysql connection error : %s \n", mysql_error(&m_sConn));
return false;
}
Log("------------------------------------------------------------\n");
Log(" * Mysql connected : host(%s), schema(%s) \n", _host,_schema);
Log("------------------------------------------------------------\n");
m_bConnected=true;

return true;
}

int CMySql::InsertRecord( const char* _table, const char* _field,const char* _value )
{
int query_stat;
char query[512];
sprintf(query,"INSERT INTO `%s` (%s) VALUE ( %s );",_table,_field,_value);
query_stat=mysql_query(m_psConnection,query);

if (0!=query_stat)
{
Log(" * Mysql query error : %s \n", mysql_error(&m_sConn));
return 1;
}

return 0;
}

int CMySql::Select( void* _data,const char* _query )
{
int fieldNo,i;
int query_stat;
MYSQL_RES *sql_result;
MYSQL_ROW sql_row;
query_stat=mysql_query(m_psConnection,_query);

if (0!=query_stat)
{
Log(" * Mysql query error : %s \n", mysql_error(&m_sConn));
return 1;
}

sql_result=mysql_store_result(m_psConnection);
while((sql_row=mysql_fetch_row(sql_result))!=NULL)
{
printf("* ");
fieldNo=mysql_num_fields(sql_result);
for(i=0;i
{
printf("%s ",sql_row[i]);
//_data++=*sql_row[i]++;
}

printf("\n");
}
mysql_free_result(sql_result);


return 0;
}

int CMySql::ExecuteQueryString( const char* _query)
{
int query_stat;

query_stat=mysql_query(m_psConnection,_query);

if (query_stat!=0)
{
Log(" * Mysql query error : %s \n", mysql_error(&m_sConn));
return 1;
}

return 0;
}

MYSQL_RES* CMySql::GetResult()
{
MYSQL_RES *sql_result;

sql_result=mysql_store_result(m_psConnection);

return sql_result;
}

void CMySql::FreeResult( MYSQL_RES* sql_result)
{
ASSERT(sql_result);
mysql_free_result(sql_result);
}

//수정과 보완이 많이 필요한 것이다..