Utilidad para albergar "numeros" que pueden tener minimo y maximo, por

ejemplo un sistema de particulas tiene que crear particulas con valores

aleatorios para el color digamos entre 0 y 255.

Código [Seleccionar] Expand





/*



CMinMax.h



*/





#pragma once



#include "Types.h"





template <class T> class CMinMax

{

private:



//

//members

//

T m_Min;

T m_Max;

 





public:



//

//life

//

CMinMax()

{

 Clear ();

}

CMinMax (T tMin, T tMax)

{

 m_Min = tMin;

 m_Max = tMax;

}

~CMinMax()

{

}







//

//operators

//

inline bool operator == (const CMinMax <T> &minmax)

{

 return (m_Min == minmax.m_Min && m_Max == minmax.m_Max) ?



true : false;

}

inline bool operator != (const CMinMax <T> &minmax)

{

 return (*this == minmax) ? false : true;

}



//

//operations

//

inline CMinMax <T>& operator = (const CMinMax <T> &minmax)

{

 m_Min = minmax.m_Min;

 m_Max = minmax.m_Max;

 return *this;

}



inline void Clear (void) { m_Min = T(); m_Max = T(); }



inline void SetMinMax (const T min, const T max) { m_Max = max;



m_Min = min; }



inline T GetRange(void) { return(T)(abs((int)(m_Max-m_Min))); }



inline T GetRandom (void)

{

 return (T)(m_Max-m_Min) > 0 ? rand ()%(int)(m_Max-m_Min) +



m_Min : rand ()%(int)(1) + m_Min;

}



};









Éste código fue enviado por Corday el 9 de enero de 2003  

Si quieres enviar tu propio código hazlo a  

eth_cotd@lycos.es

Uff, el rack donte tengo el código antiguo anda medio jodido :S, se desconecta sólo.
Tras 2 cuelgues, he decidido escribir el código de cabeza. Disculpas si sale algo mal :(

Un logger simple, singleton. Usa streams en vez de lista de argumentos variable
,sintaxis del printf() de C, así que es typesafe, extensible, y cómodo ;)

Lo fundamental es la idea, ya que el código es un ejemplo, cada uno tiene su
sistema de loggeo adaptado a su uso particular,excepciones propias, distintos
logs para cada subsistema,logs en debug al compilador mediante OutputDebugString() etc, etc...

como todo en esta vida, lo simple puede
complicarse ;)

Como el COTD se basa en como usar streams para loggear, no he querido liar el código
aún más por el asunto del singleton. Está implementado como en el Design Patterns
así que algunos sabréis que el destructor no se llama :(, un leak que en éste caso
no importa, pero con otros recursos puede importar. En el Modern C++ design viene
un capítulo dedicado a implementar singletons.

Para usar el logger, se recurre normalmente a macros. La mayoría de los logs
que se usan utilizan los macros__FILE__ y __LINE__, así que hay que usar
macros por cojones. En éste caso ayudan también ha que se use el logger con
un sintaxis normal(directamente sería CLogger::Instance().Log()<<"Hola"<, largo  y raro, eh? ;) )

He hecho distintas distinciones:

LOG() y LOGLN().  LOGLN() añade un salto de página.

     LOG() y LOG_ERRROR() . EL log de errores añade el fichero y la línea
                donde se llama.
   
    Existe también LOG_DEBUG() para info que sólo queremos loggear en modo debug

Código [Seleccionar] Expand



/////////////////////////////

//

// fichero: CLogger.h

//

/////////////////////////////

#ifndef _CLOGGER_H

#define _CLOGGER_H



//-------------INCLUDES--------------------

#include <iostream>

#include <fstream>

#include <string>





class CLogger

{

public:

static CLogger& Instance(const char* FilePath="Log.txt");

std::ofstream& Log(){return m_FileStream;}



private:

void Init(const char* FilePath);



/* La creación y destrucción del singleton de forma explícita se prohibe*/

CLogger(){};

CLogger(const CLogger& Logger);

CLogger& operator=(const CLogger& Logger);

~CLogger();

/**/



/*el fichero donde escribimos el log*/

std::ofstream   m_FileStream;



static CLogger*  ms_pInstance;



};



//---------------------DEFINES----------------



//Por comodidad, podemos tratar al singleton como si fuera una variable global

#define g_Logger  CLogger::Instance()





#define LOG(TEXT) {g_Logger.Log()<<TEXT;}



#define LOGLN(TEXT) {g_Logger.Log()<<TEXT<<std::endl;}







#ifdef _DEBUG

//logs que sólo queremos en modo debug



#define LOG_DEBUG(TEXT) {g_Logger.Log()<<TEXT;}

#define LOGLN_DEBUG(TEXT) {g_Logger.Log()<<TEXT<<std::endl;}



#else

//en release no los escribimos

#define LOG_DEBUG(TEXT) {}

#define LOGLN_DEBUG(TEXT) {}



#endif



//los logs de errores añaden el fichero y la línea donde se llama



#define LOG_ERROR(TEXT) {g_Logger.Log()<<"FATAL_ERROR!: "<< TEXT

 <<" AT FILE: "<<__FILE__<<" IN LINE: "<<__LINE__;}



#define LOGLN_ERROR(TEXT) {g_Logger.Log()<<"FATAL_ERROR!: "<< TEXT

 <<" AT FILE: "<<__FILE__<<" IN LINE: "<<__LINE__<<std::endl;}



#endif //_CLOGGER_H





/////////////////////////////

//

//fichero: CLogger.cpp

//

/////////////////////////////



#include "CLogger.h"

#include <exception>





//Linkamos las variables estáticas

CLogger* CLogger::ms_pInstance=NULL;



//--------------CLOGGER()----------------

void CLogger::Init(const char* FilePath)

{

m_FileStream.open(FilePath,std::ios::out|std::ios::trunc);



if(m_FileStream==NULL)//No podemos crear un fichero de log :(

 throw std::exception("Couldn´t open file stream");

}



//-----------------~CLOGGER()---------------

CLogger::~CLogger()

{

delete ms_pInstance;

ms_pInstance=NULL;

m_FileStream.close();



}

//----------------INSTANCE()----------------

//Punto de acceso al singleton. Se creará en la primera llamada.

CLogger& CLogger::Instance(const char* FilePath)

{

if(ms_pInstance==NULL)

{  

 ms_pInstance=new CLogger();

 ms_pInstance->Init(FilePath);

}





return *ms_pInstance;

}



/////////////////////////////

//

//fichero main.cpp

//

/////////////////////////////



#include "CLogger.h"

#include <iostream>





void main()

{

/*Creamos el fichero de log*/

CLogger::Instance("LogPrueba.txt");



int i=22;





LOGLN("Hola soy Grug, tengo "<<i<<" años ,llego tarde y la novia me mata... chaops


;)");



/*llamada sin macro.*/

g_Logger.Log()<<"Hola soy Grug, tengo "<<i<<" años "<<" y  la novia me mata... chaops


;)"<<std::endl;



LOGLN_ERROR("Error!, kk de ejemplo;)");

}





Éste código fue enviado por Grugnorr el luneas, 30 de diciembre del 2002.

Si quieres enviar tu propio código hazlo a  

eth_cotd@lycos.es

[Puede bajarte el codigo de aqui:]

    Esta aplicacion basada en MFC sirve para mostrar el uso de la clase     CConnectionManager. Esta clase se encarga de llevar todo el sistema de conexiones mediante UDP por lo que esta especialmente preparada para juegos en red. Puede funcionar tanto como cliente como servidor.
   La aplicacion en si es un pequeño chat.

Puede bajarte el codigo de aqui:

               http://www.stratos-ad.com/codigosemana/pekechat.zip


Éste código fue enviado por AK47 el domingo, 22 de diciembre del 2002  

Si quieres enviar tu propio código hazlo a  eth_cotd@lycos.es

No la he visto ni me interesa verla pero alguien tenia q empezar el thread xDDD.

saludos

[Puedes bajarte el codigo de]

  Al comienzo de verano del 2002 decidi meterme con c++ de lleno y lo primero q se me vino a la mente fue una implementacion de sockets. Empece con una clase socket despues añadir UDP y mas tarde TCP y una clase para manejo de IP's. El resultado de todo esto es esta ofuscada libreria q aqui os dejo ;).

   La libreria en si son 4 clases q podeis ver en sock.h. Con ellas se pueden manejar sockets UDP, TCP e ip's "facilmente". He puesto  un ejemplo de manejo de sockets TCP y para ello he credo una clase Server y Cliente. En el server uso threads para atender a los clientes ( tenia ganas de hacer algo con threads y q mejor ocasion :) aunque seguramente tendra algun fallo debido a mi poca experiencia con threads ( a ver si alguien encuentra el fallo gordo ;).
 
 Un ejemplo de uso es:

Código [Seleccionar] Expand



       if(argc >= 2){

               //cliente



       Client cl;

       cl.Connect(CIP("localhost",80),"hola hola;@@@");



       }

       else {

       MyServer server;

       if(!server.Init(CIP("127.0.0.1",80))) return 0;

       server.MainLoop(); //ctrl + c friend xD



       }

       return 1;

 


  A ver si os animais a mandar cotw, esta semana no ha llegado ninguno y como veis esta semana, cualquier codigo vale aunque penseis q es asqueroso e inutil.

Un saludo

Javier Santana :: ethernet


Puedes bajarte el codigo de
         
                    http://www.stratos-ad.com/codigosemana/sock.zip


     Éste código fue enviado el martes 11 de diciembre del 2002 por Javier Santana qualopec@lycos.es

     Si quieres enviar tu propio código hazlo a eth_cotd@lycos.es

Hola, en mi proyecto de fin de carrera he desarrollado un reconocedor de voz independiente del locutor y ahora me queda la parte en la q debo darle un uso.

Para q usariais vosotros un reconocedor de voz? en cosas de la vida cotidiana o no tan cotidiana lo usariais?

Nota: el reconocedor no distingue el locutor solamente pasa de voz a texto.

saludos y gracias de antemano

[Puedes bajarte el codigo de:]

La clase que mando se encarga de reciclar nodos que han sido
creados en memoria. Para ello, éstos se crearán una sola vez
usando new y no serán destruidos con delete hasta que se finalice
la instancia a la clase. Las llamadas new y delete son muy
costosas, sobre todo cuando las necesitamos hacer de forma
numerosa y en grandes cantidades, haciendo que la velocidad de
procesado de nuestros algoritmos se vean seriamente dañada en el
momento en que comenzamos a utilizarlos de forma reiterada. No
hay que confundir esta clase con un manejador de memoria pero si
apuntar que en caso de disponer de uno, CRecycleNodePool se
podría beneficiar de su uso; bastaría sustituir las llamadas new
y delete internas por las del manejador

Así pues, la principal utilidad de CRecycleNodePool es la de
servir de apoyo a algoritmos en los que hace falta la creación de
un número elevado de nodos de información a consultar. De esta
forma, los algoritmos de IA pueden beneficiarse en gran medida
Un ejemplo es el de búsqueda de caminos A*, que necesita de la
creación de una gran cantidad de nodos con datos heurísticos, o
cualquier proceso backtraking en general. Sin embargo, también
podemos encontrar de gran utilidad esta clase en el trabajo con
subsistemas gráficos que funcionen en dos pasadas, esto es, con
una destinada a alojar las peticiones de dibujado (que irían en
nodos) y con otra encargada de recorrer todas las peticiones
previas para realizar el dibujado propiamente dicho

Como apuntes sobre el código, decir que he utilizado las STL para
tratar las estructuras de datos de apoyo (mantengo una lista de
nodos disponible y un conjunto de nodos usados) y uso el
protocolo Init / End que Javier Arévalo expuso hace tiempo en
Flipcode
(

http://www.flipcode.com/cgi-bin/msg.cgi?showThread=Tip-ObjectIni
tFinal&forum=totd&id=-1). La clase está implementada como
template para permitir la creación de un almacén genérico
También acudo a los asertos bastante a menudo (recomiendo que
cada cual sustituya los assert por sus propias macros), ya que
permiten asegurar el codigo en fase de desarrollo y contribuyen a
comentarlo

Para finalizar, paso a comentar muy brevemente los métodos
públicos existentes (hay comentarios más exhaustivos en el
código)

bool Init(const unsigned short& usInitSize = 0)

Inicializa / reinicializa la instancia. Recibe el tamaño inicial
del pool (almacén) de memoria

void End(void);

Finaliza la instancia

inline bool IsInitOk(void) const

Comprueba si la instancia esta correctamente inicializada

Node* GetNode(void);

Obtiene un nodo (si no fuera posible, retornará dirección nula)

void FreeNode(Node* const pNode);

Libera un nodo previamente solicitado con GetNode (nótese no se
llamará a delete)

void Realloc(const unsigned short& usNewSize);

Redimensiona el pool de nodos disponibles

inline unsigned short GetNumFreeNodes(void) const

Obtiene el número de nodos disponibles

inline unsigned short GetNumUsedNodes(void) const

Obtiene el número de nodos actualmente usados


Puedes bajarte el codigo de:

http://www.stratos-ad.com/codigosemana/cre...clenodepool.zip  




Éste código fue enviado el martes 3 de diciembre del 2002  por Fernando Rodríguez frodrig99@yahoo.com

Si quieres enviar tu propio código hazlo a eth_cotd@lycos.es

La manera mas rapida de calcular las normales por vertice de una malla ? Hace un tiempo tenia un objeto q se deformaba y tenia q calcular las normales cada frame y era batante lento.

saludos y gracias.

Una simple función para depuración que utiliza elipses para igualar la facilidad de usa que posee el TRACE del VisualC++ cuando se utiliza MFC.

Complementamos la utilidad de este código con el DebugView de sysinternals (que es freeware) y la podemos descargar de aquí http://www.sysinternals.com/ntw2k/freeware...debugview.shtml.

Esta utilidad nos permitirá ver los mensajes que arroje el OutputDebugString.

De este modo utilizando cualquier compilador y sólo lenguaje C estandar podemos depurar nuestro programa facilmente.

Ejemplos de uso:

Código [Seleccionar] Expand


void main(void)

{

   int nValor = 4;

   char * str = "stratos AD";  



   // ...



   trace("Valor: %d Nombre %s", nValor, str);



   // ...

}



Mejoras: En mi caso la función trace es en realidad un método de una clase y szBuf es una propiedad de dicha clase, de este modo no es necesario asignar 256 bytes en el heap cada vez que se invoca la función sino que se asigna en el constructor de la clase una sola vez.

También podría  ser declarada como static.

Saludos.
Diego G. Ruiz (deadLock++)




Código [Seleccionar] Expand


void trace(char * pszText, ....)

{

va_list argptr;

short i;



char szBuf[256];



va_start(argptr, pszText);

i = vsprintf(szBuf, pszText, argptr);

va_end(argptr);



OutputDebugString(szBuf);



return;



}




Éste código fue enviado por Diego G. Ruiz (deadLock++) el 26 de noviembre del 2002
diego.ruiz@neptra.com
Si quieres enviar tu propio código hazlo a  
eth_cotd@lycos.es

Silencio ...

¿ Necesita explicación ? :)

Código [Seleccionar] Expand





// vector.h



#ifndef CXVECTOR

#define CXVECTOR



class CXMatriz;



class CXVector:public D3DXVECTOR3 {

public:

CXVector() {};

CXVector(float xyz) { x=xyz;y=xyz;z=xyz; };

CXVector(const CXVector &origen);

CXVector(float x,float y,float z);

CXVector &Normalizar();

CXVector NormalizarNuevo();

float ProductoEscalar(const CXVector &v);

CXVector ProductoVectorial(const CXVector &v1);

float Magnitud();

void ResetAlMaximo(); // Asigna un nº máximo

CXVector &operator /(float escalar);

CXVector &operator *=(const CXMatriz &m);

friend CXVector operator *(const CXVector &v,const CXMatriz &m);

friend CXVector operator -(CXVector &a,CXVector &b);

friend CXVector operator -(CXVector &a);

friend CXVector operator +(CXVector &a,CXVector &b);

friend CXVector operator *(CXVector &a,float escalar);

friend CXVector operator *(float escalar,CXVector &a);

};



#endif



// vector.cpp

#include "haddd.h"



CXVector::CXVector(float vx,float vy,float vz)

{

x=vx;

y=vy;

z=vz;

}



CXVector::CXVector(const CXVector &v)

{

x=v.x;

y=v.y;

z=v.z;

}



void CXVector::ResetAlMaximo()

{

x=FLT_MAX;

y=FLT_MAX;

z=FLT_MAX;

}

float CXVector::Magnitud()

{

return D3DXVec3Length(this);

}



CXVector &CXVector::Normalizar()

{

D3DXVec3Normalize(this,this);



return *this;

}



CXVector CXVector::NormalizarNuevo()

{ CXVector t;



D3DXVec3Normalize(&t,this);



return t;

}



CXVector CXVector::ProductoVectorial(const CXVector &v1)

{ CXVector t;



D3DXVec3Cross(&t,this,&v1);



return t;

}



float CXVector::ProductoEscalar(const CXVector &v)

{

return D3DXVec3Dot(this,&v);



}



CXVector &CXVector::operator /(float escalar)

{

x/=escalar;

y/=escalar;

z/=escalar;



return *this;

}



CXVector &CXVector ::operator *=(const CXMatriz &m)

{

D3DXVECTOR4 v4;

D3DXVec3Transform(&v4,(D3DXVECTOR3 *)&x,(D3DXMATRIX *)m.m);

x=v4.x;

y=v4.y;

z=v4.z;

return *this;

}





// Funciones amigas



CXVector operator *(CXVector &a,float escalar)

{

CXVector t(a);

t.x*=escalar;

t.y*=escalar;

t.z*=escalar;



return t;

}



CXVector operator *(float escalar,CXVector &a)

{

CXVector t(a);

t.x*=escalar;

t.y*=escalar;

t.z*=escalar;



return t;

}



CXVector operator +(CXVector &a,CXVector &b)

{

CXVector t(a);

t.x+=b.x;

t.y+=b.y;

t.z+=b.z;



return t;

}



CXVector operator -(CXVector &a,CXVector &b)

{

CXVector t(a);

t.x-=b.x;

t.y-=b.y;

t.z-=b.z;



return t;

}



CXVector operator -(CXVector &a)

{

CXVector t;

t.x=-a.x;

t.y=-a.y;

t.z=-a.z;



return t;

}



CXVector operator *(const CXVector &v,const CXMatriz &m)

{

D3DXVECTOR4 v4;

D3DXVec3Transform(&v4,(D3DXVECTOR3 *)&v.x,(D3DXMATRIX *)m.m);

return CXVector(v4.x,v4.y,v4.z);

}









Éste código fue enviado por Drácula el 22 de noviembre del 2002

dracular@ono.com

Si quieres enviar tu propio código hazlo a  eth_cotd@lycos.es

Tutti-frutti de codigo que pueden ser utiles para cualquier proyecto, sobre todo para Visual C++

*Martin B.R.*
martin@martinbr.com
http://www.martinbr.com
"La vida es corta... *JUEGA MAS*"



Código [Seleccionar] Expand


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//

// __   __ ___  ___  _ __ ___  _ __ ___   ___  _ __

//   / // __|/ _ | '_ ` _ | '_ ` _  / _ | '_

//   V /| (__| (_) | | | | | | | | | | | (_) | | | |

//   _/  ___|___/|_| |_| |_|_| |_| |_|___/|_| |_| v1.09

//

/// file    VCOMMON.H

/// brief   Definiciones comunes utiles

///          Fuentes de varios autores

/// version 1.09

/// todo    

/// bug    

/// warning

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/// author  Martin B.R. date 11/06/2001

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/// Eurisko software (c) http://www.martinbr.com

/// martin@martinbr.com

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef _VCOMMON_H

#define _VCOMMON_H



//! Procesador

#if defined(_M_IX86)

# define _PROCESSOR_NAME  "x86"

# define _LITTLE_ENDIAN

#elif defined(_M_MPPC)

# define _PROCESSOR_NAME  "Power Macintosh"

#elif defined(_M_ALPHA)

# define _PROCESSOR_NAME  "Alpha"

#elif defined(_M_MRX000)

# define _PROCESSOR_NAME  "MIPS"

#elif defined(_M_PPC)

# define _PROCESSOR_NAME  "Power PC"

#else

# define _PROCESSOR_NAME  "Unkown"

#endif



//! Plataforma

#if defined(_WIN32)

# define _PLATFORM_NAME "Win32"

# define WIN32_MEAN_AND_LEAN        /// Elimina librerias no usadas

# include "windows.h"

#elif defined(LINUX)

# define _PLATFORM_NAME "Linux"

#endif



#if defined (_MSC_VER)

# define _COMPILER_NAME "Microsoft Visual C++"

# ifdef _DEBUG

#   pragma warning(disable:4800)    /// Forcing value to bool

#   pragma warning(disable:4201)    /// structure/ union without name. (Only relevant on MSVC 5.0)

#   pragma inline_depth(255)        /// Sin limite (8 por defecto)

#   pragma inline_recursion(on)     /// off por defecto

#   pragma auto_inline(on)

#endif



#define INLINE __inline            /// True inline



/// Tipos basicos

#ifndef NULL

# define NULL 0

#endif



#ifndef true

# define true 1

#endif

#ifndef false

# define false 0

#endif



#ifndef TRUE

# define TRUE 1

#endif

#ifndef FALSE

# define FALSE 0

#endif



typedef signed char       S8, schar;    /// Signed 8 bits

typedef unsigned char     U8, uchar;    /// Unsigned 8 bits

typedef signed short      S16, sshort;  /// Signed 16 bits

typedef unsigned short    U16, ushort;  /// Unsigned 16 bits

typedef signed int        S32, sint;    /// Signed 32 bits (16)

typedef unsigned int      U32, uint;    /// Unsigned 32 bits (16)

typedef signed __int64    S64, sint64;  /// Signed 64 bits

typedef unsigned __int64  U64, uint64;  /// Unsigned 64 bits

typedef float             F32;          /// Coma 32 bits

typedef double            F64;          /// Coma 64 bits

typedef unsigned long     UID, DWORD;   /// Identificador unico

typedef void*             HANDLE;

typedef long              RESULT;       /// aka HRESULT



#ifndef OK

# define OK ((RESULT)0x00000000L)

#endif



#ifndef FAIL

# define FAIL ((RESULT)0x80004005L)

#endif



#ifndef ISFAIL

# define ISFAIL(a) ((RESULT)(a)<0)

#endif



/// Constantes

static const F32 FLOAT_ONE  = F32(1.0);

static const F32 FLOAT_ZERO = F32(0.0);



static const S8  S8_MIN  = S8(-128);

static const S8  S8_MAX  = S8(127);

static const U8  U8_MAX  = U8(255);



static const S16 S16_MIN = S16(-32768);

static const S16 S16_MAX = S16(32767);

static const U16 U16_MAX = U16(65535);



static const S32 S32_MIN = S32(-2147483647 - 1);

static const S32 S32_MAX = S32(2147483647);

static const U32 U32_MAX = U32(0xffffffff);



static const F32 F32_MAX = F32(3.402823466e+38F);

static const F32 F32_MIN = F32(1.175494351e-38F);



/// Compiladores que usan el viejo estilo de casting de C++ deben definir _USE_OLD_STYLE_CASTS

#if defined(_USE_OLD_STYLE_CASTS)

# define _CAST(C, T, V) ((T)(V))

#else

# define _CAST(C, T, V) (C<T>(V))

#endif



#define STATIC_CAST(T, V)       _CAST(static_cast, T, V)

#define DYNAMIC_CAST(T, V)      _CAST(dynamic_cast, T, V)

#define REINTERPRET_CAST(T, V)  _CAST(reinterpret_cast, T, V)

#define CONST_CAST(T, V)        _CAST(const_cast, T, V)



#define LOW_BYTE(a)             (((a)&0x00ff))

#define HIGH_BYTE(a)            (((a)>>8))

#define SET_LOW_BYTE(num,low)   ((((num)&0x0000ff00)|LOW_BYTE((low))))

#define SET_HIGH_BYTE(num,high) ((LOW_BYTE(num)|((high)&0x0000ff00)))

#define LOW_WORD(a)             (((a)&0x0000ffff))

#define HIGH_WORD(a)            (((a)>>16))

#define SET_LOW_WORD(num,low)   ((((num)&0xffff0000)|LOW_WORD(low)))

#define SET_HIGH_WORD(num,high) ((LOW_WORD(num)|((high)&0xffff0000)))



#define RED(rgb)                (((rgb)>>16)&0xff)

#define GREEN(rgb)              (((rgb)>>8)&0xff)

#define BLUE(rgb)               ((rgb)&0xff)

#define ALPHA(rgba)             (((rgba)>>24)&0xff)



#define MAKE_RGB16(r,g,b)       (((ushort)(r)<<11)|((ushort)(g)<<5)|(ushort)(b))

#define MAKE_RGB(r,g,b)         (0xff000000|((DWORD)((uchar)(r))<<16)|((DWORD)((uchar)(g))<<8)|(DWORD)((uchar)(b)))

#define MAKE_RGBA(a,r,g,b)      (((DWORD)((uchar)(a))<<24)|((DWORD)((uchar)(r))<<16)|((DWORD)((uchar)(g))<<8)|(DWORD)((uchar)(b)))

#define MAKE_ARGB(a,r,g,b)      ((DWORD)((((a)&0xff)<<24)|(((r)&0xff)<<16)|(((g)&0xff)<<8)|((b)&0xff)))



/// Depuracion

#ifdef _DEBUG

# include <cassert>

# undef ASSERT

# define ASSERT(test, msg)                                                                        

 {                                                                                              

   if (!(test))                                                                                  

   {                                                                                            

     static bool bAssert = true;                                                                

     if (bAssert)                                                                                

     {                                                                                          

       static char text[199]="";                                                                

                                                                                                 

       wsprintf(text, "FAILEDt: %sn"                                                          

       "Errort: %sn"                                                                          

       "Filet: '%s':%dnn"                                                                    

       "Abort execution, allow assert Retry, or Ignore in future?",                              

       #test, #msg, __FILE__, __LINE__);                                                        

                                                                                                 

       switch (::MessageBox(NULL, text, "ASSERTION ERROR", MB_ABORTRETRYIGNORE|MB_ICONWARNING))  

       {                                            

         case IDIGNORE:                                                                          

         bAssert = false;                                                                        

         break;                                                                                  

         case IDABORT:                                                                          

         { _asm { int 3 } }                                                                      

       }                                                                                        

     }                                                                                          

   }                                                                                            

 }

# define CHK_SUCCESS(a)     assert(SUCCEEDED(a))

# define CHK_RESULT(a, h)   assert(a == h)

# define CHK_FAILED(a)      { if (ISFAIL(a)) { MessageBox(NULL, #a " Failed!", NULL, MB_OK|MB_ICONERROR); ::ExitProcess(1); } }

# define ODS(a)             OutputDebugString(a)

# define CRASH              { int *a = 0; *a = 1; } /// Peta el ordenador!!

#else

# define ASSERT(test, msg)  ((void)0)

# define CHK_SUCCESS(a)     (a)

# define CHK_RESULT(a, h)   (a)

# define CHK_FAILED(a)      (a)

# define ODS(a)

# define CRASH

#endif



/// Misc

#undef INIT

#define INIT(a)             { (a) = NULL; }



#undef ISOK

#define ISOK(a)             ((a) != NULL)



#undef DELNULL

#define DELNULL(a)          { if ((a) != NULL) { delete (a); (a) = NULL; } }



#undef RELEASENULL

#define RELEASENULL(a)      { if ((a) != NULL) { (a)->Release(); (a) = NULL; } }



#undef DELARRAYNULL

#define DELARRAYNULL(a)     { if ((a) != NULL) { delete[] (a); (a) = NULL; } }



/// FIXMEs / TODOs / NOTEs

#define _QUOTE(a)           #a

#define QUOTE(x)            _QUOTE(x)

#define __FILE__LINE__      __FILE__ "(" QUOTE(__LINE__) ") : "



#define NOTE(a)             message(a)

#define FILE_LINE           message(__FILE__LINE__)



#define todo(a)             message(__FILE__LINE__" TODO :   " #a "n")

#define fixme(a)            message(__FILE__LINE__" FIXME:   " #a "n")



#define TODO(a)             message(__FILE__LINE__"n"  

 " ------------------------------------------------n"

 "|  TODO :   " #a "n"                                

 " ------------------------------------------------n")

#define FIXME(a)            message(__FILE__LINE__"n"  

 " ------------------------------------------------n"

 "|  FIXME :  " #a "n"                                

 " ------------------------------------------------n")



#endif // _VCOMMON_H

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// End Of File

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////





Éste código fue enviado por martinbr el jueves, 14 de noviembre del 2002
martin@martinbr.com

Si quieres enviar tu propio código hazlo a  eth_cotd@lycos.es

Q pasa no teneis codigos par enviar o q? Me asombra la poca cantidad de codigos q han llegado con la aceptacion q habia tenido en la encuesta q se puso aqui hace unas semanas.

No es necesario q hagais algo especial para mandar, simplemente enviad algun codigo o libreria o lo q querais q tengais ya hecho y q creais q puede ser util o q tenga algo especial q enseñar.

Ya sabeis: eth_cotd@lycos.es
saludos ;)

Esta función realiza el desenfoque de una imagen. Lo que hace es sumar todos los colores que hay alrededor de cada pixel y hacer la media, dandole más importancia al color central (8 veces más importancia), según el siguiente esquema:

pixel1  pixel2  pixel3             1   1   1

pixel4  pixel5  pixel6      *      1   8   1

pixel7  pixel8  pixel9             1   1   1

pixel5 = (pixel1*1 + pixel2*1 + pixel3*1 + pixel4*1 + pixel5*8 + pixel6*1 + pixel7*1 + pixel8*1 + pixel9*1) / 16

La función necesita de 5 variables para su funcionamiento (yo las tengo como variables miembro de la superficie). Las variables son:

m_lpBuffer = Es el puntero al inicio de la superficie. En el caso de una superficie DX se puede conseguir con la función Lock

m_lPitch   = Es el número de bytes de cada línea de la superficie. En el caso de una superficie DX se puede conseguir con la función Lock

m_bpp      = Son los bits bor pixel de la superficie

m_bypp     = Son los bytes por pixel de la superficie. Aunque este valor tambien se puede deducir de la variable anterior

m_Rect     = Está almacenado el rectángulo de la superficie (tamaño)

Mediante la configuración de estas variables se controla el tamaño y el formato de la imagen, por lo que se puede aplicar la función a una superficie de render, una textura, etc

Cuantas más veces seguidas se llama a la función, más efecto de desenfoque se produce

Hay que tener en cuenta que aunque está hecha con funciones MMX, no deja de ser muy lenta, así que solo se puede usar para cosas muy puntuales o simplemente como curiosidad

Código [Seleccionar] Expand



void Superficie::Desenfoque()

{

int maxlinea,pixelsx,pixelsy,bypp,bpp,incxlinea,maxlinea2,contpixel;

unsigned char *dirw;

dirw=m_lpBuffer;

maxlinea=m_lPitch;

bypp=m_bypp;  

bpp=m_bpp;

pixelsx=m_Rect.Width()-2;

pixelsy=m_Rect.Height()-2;

_asm{

 mov eax,maxlinea

 mov esi,eax

 shl eax,1

 mov maxlinea2,eax

 mov eax,pixelsx

 imul bypp

 mov edx,esi

 sub edx,eax

 mov incxlinea,edx

 sub esi,bypp

 mov edi,dirw

 add edi,maxlinea

 add edi,bypp

 psrld mm7,32

linea:

 mov eax,pixelsx

 mov contpixel,eax

 cmp bpp,32

 jz linea32

 cmp bpp,24

 jz linea24

 cmp bpp,16

 jz linea16

linea15:

 sub esi,maxlinea2

 mov ax,word ptr [edi+esi]

 mov bx,word ptr [edi+esi+2]

 shrd edx,eax,5

 shrd ecx,ebx,5

 shr eax,5

 shr ebx,5

 shr edx,3

 shr ecx,3

 shrd edx,eax,5

 shrd ecx,ebx,5

 shr eax,5

 shr ebx,5

 shr edx,3

 shr ecx,3

 shrd edx,eax,13

 shrd ecx,ebx,13

 movd mm0,edx

 punpcklbw mm0,mm7

 movd mm1,ecx

 punpcklbw mm1,mm7

 paddw mm0,mm1

 mov ax,word ptr [edi+esi+4]

 add esi,maxlinea

 mov bx,word ptr [edi+esi]

 shrd edx,eax,5

 shrd ecx,ebx,5

 shr eax,5

 shr ebx,5

 shr edx,3

 shr ecx,3

 shrd edx,eax,5

 shrd ecx,ebx,5

 shr eax,5

 shr ebx,5

 shr edx,3

 shr ecx,3

 shrd edx,eax,13

 shrd ecx,ebx,13

 movd mm1,edx

 punpcklbw mm1,mm7

 paddw mm0,mm1

 movd mm1,ecx

 punpcklbw mm1,mm7

 paddw mm0,mm1

 mov ax,word ptr [edi+esi+2]

 mov bx,word ptr [edi+esi+4]

 shrd edx,eax,5

 shrd ecx,ebx,5

 shr eax,5

 shr ebx,5

 shr edx,3

 shr ecx,3

 shrd edx,eax,5

 shrd ecx,ebx,5

 shr eax,5

 shr ebx,5

 shr edx,3

 shr ecx,3

 shrd edx,eax,13

 shrd ecx,ebx,13

 movd mm1,edx

 punpcklbw mm1,mm7

 psllw mm1,3

 paddw mm0,mm1

 movd mm1,ecx

 punpcklbw mm1,mm7

 paddw mm0,mm1

 add esi,maxlinea

 mov ax,word ptr [edi+esi]

 mov bx,word ptr [edi+esi+2]

 shrd edx,eax,5

 shrd ecx,ebx,5

 shr eax,5

 shr ebx,5

 shr edx,3

 shr ecx,3

 shrd edx,eax,5

 shrd ecx,ebx,5

 shr eax,5

 shr ebx,5

 shr edx,3

 shr ecx,3

 shrd edx,eax,13

 shrd ecx,ebx,13

 movd mm1,edx

 punpcklbw mm1,mm7

 paddw mm0,mm1

 movd mm1,ecx

 punpcklbw mm1,mm7

 paddw mm0,mm1

 mov ax,word ptr [edi+esi+4]

 shrd edx,eax,5

 shr eax,5

 shr edx,3

 shrd edx,eax,5

 shr eax,5

 shr edx,3

 shrd edx,eax,13

 movd mm1,edx

 punpcklbw mm1,mm7

 paddw mm0,mm1

 psrlw mm0,4

 packuswb mm0,mm0

 movd eax,mm0

 shr eax,3

 shrd edx,eax,5

 shr eax,8

 shrd edx,eax,5

 shr eax,8

 shrd edx,eax,22

 mov word ptr [edi],dx

 add edi,2

 dec contpixel

 jnz linea15

 mov eax,pixelsx

 mov contpixel,eax

 add edi,incxlinea

 dec pixelsy

 jnz linea15

 jmp final

linea16:

 sub esi,maxlinea2

 mov ax,word ptr [edi+esi]

 mov bx,word ptr [edi+esi+2]

 shrd edx,eax,5

 shrd ecx,ebx,5

 shr eax,5

 shr ebx,5

 shr edx,2

 shr ecx,2

 shrd edx,eax,6

 shrd ecx,ebx,6

 shr eax,6

 shr ebx,6

 shr edx,3

 shr ecx,3

 shrd edx,eax,13

 shrd ecx,ebx,13

 movd mm0,edx

 punpcklbw mm0,mm7

 movd mm1,ecx

 punpcklbw mm1,mm7

 paddw mm0,mm1

 mov ax,word ptr [edi+esi+4]

 add esi,maxlinea

 mov bx,word ptr [edi+esi]

 shrd edx,eax,5

 shrd ecx,ebx,5

 shr eax,5

 shr ebx,5

 shr edx,2

 shr ecx,2

 shrd edx,eax,6

 shrd ecx,ebx,6

 shr eax,6

 shr ebx,6

 shr edx,3

 shr ecx,3

 shrd edx,eax,13

 shrd ecx,ebx,13

 movd mm1,edx

 punpcklbw mm1,mm7

 paddw mm0,mm1

 movd mm1,ecx

 punpcklbw mm1,mm7

 paddw mm0,mm1

 mov ax,word ptr [edi+esi+2]

 mov bx,word ptr [edi+esi+4]

 shrd edx,eax,5

 shrd ecx,ebx,5

 shr eax,5

 shr ebx,5

 shr edx,2

 shr ecx,2

 shrd edx,eax,6

 shrd ecx,ebx,6

 shr eax,6

 shr ebx,6

 shr edx,3

 shr ecx,3

 shrd edx,eax,13

 shrd ecx,ebx,13

 movd mm1,edx

 punpcklbw mm1,mm7

 psllw mm1,3

 paddw mm0,mm1

 movd mm1,ecx

 punpcklbw mm1,mm7

 paddw mm0,mm1

 add esi,maxlinea

 mov ax,word ptr [edi+esi]

 mov bx,word ptr [edi+esi+2]

 shrd edx,eax,5

 shrd ecx,ebx,5

 shr eax,5

 shr ebx,5

 shr edx,2

 shr ecx,2

 shrd edx,eax,6

 shrd ecx,ebx,6

 shr eax,6

 shr ebx,6

 shr edx,3

 shr ecx,3

 shrd edx,eax,13

 shrd ecx,ebx,13

 movd mm1,edx

 punpcklbw mm1,mm7

 paddw mm0,mm1

 movd mm1,ecx

 punpcklbw mm1,mm7

 paddw mm0,mm1

 mov ax,word ptr [edi+esi+4]

 shrd edx,eax,5

 shr eax,5

 shr edx,2

 shrd edx,eax,6

 shr eax,6

 shr edx,3

 shrd edx,eax,13

 movd mm1,edx

 punpcklbw mm1,mm7

 paddw mm0,mm1

 psrlw mm0,4

 packuswb mm0,mm0

 movd eax,mm0

 shr eax,3

 shrd edx,eax,5

 shr eax,7

 shrd edx,eax,6

 shr eax,9

 shrd edx,eax,21

 mov word ptr [edi],dx

 add edi,2

 dec contpixel

 jnz linea16

 mov eax,pixelsx

 mov contpixel,eax

 add edi,incxlinea

 dec pixelsy

 jnz linea16

 jmp final

linea24:

 sub esi,maxlinea2

 movd mm0,dword ptr [edi+esi]

 punpcklbw mm0,mm7

 movd mm1,dword ptr [edi+esi+3]

 punpcklbw mm1,mm7

 paddw mm0,mm1

 movd mm1,dword ptr [edi+esi+6]

 punpcklbw mm1,mm7

 paddw mm0,mm1

 add esi,maxlinea

 movd mm1,dword ptr [edi+esi]

 punpcklbw mm1,mm7

 paddw mm0,mm1

 movd mm1,dword ptr [edi+esi+3]

 punpcklbw mm1,mm7

 psllw mm1,3

 paddw mm0,mm1

 movd mm1,dword ptr [edi+esi+6]

 punpcklbw mm1,mm7

 paddw mm0,mm1

 add esi,maxlinea

 movd mm1,dword ptr [edi+esi]

 punpcklbw mm1,mm7

 paddw mm0,mm1

 movd mm1,dword ptr [edi+esi+3]

 punpcklbw mm1,mm7

 paddw mm0,mm1

 movd mm1,dword ptr [edi+esi+6]

 punpcklbw mm1,mm7

 paddw mm0,mm1

 psrlw mm0,4

 packuswb mm0,mm0

 movd eax,mm0

 mov word ptr [edi],ax

 shr eax,16

 mov byte ptr [edi+2],al

 add edi,3

 dec contpixel

 jnz linea24

 mov eax,pixelsx

 mov contpixel,eax

 add edi,incxlinea

 dec pixelsy

 jnz linea24

 jmp final

linea32:

 sub esi,maxlinea2

 movd mm0,dword ptr [edi+esi]

 punpcklbw mm0,mm7

 movd mm1,dword ptr [edi+esi+4]

 punpcklbw mm1,mm7

 paddw mm0,mm1

 movd mm1,dword ptr [edi+esi+8]

 punpcklbw mm1,mm7

 paddw mm0,mm1

 add esi,maxlinea

 movd mm1,dword ptr [edi+esi]

 punpcklbw mm1,mm7

 paddw mm0,mm1

 movd mm1,dword ptr [edi+esi+4]

 punpcklbw mm1,mm7

 psllw mm1,3

 paddw mm0,mm1

 movd mm1,dword ptr [edi+esi+8]

 punpcklbw mm1,mm7

 paddw mm0,mm1

 add esi,maxlinea

 movd mm1,dword ptr [edi+esi]

 punpcklbw mm1,mm7

 paddw mm0,mm1

 movd mm1,dword ptr [edi+esi+4]

 punpcklbw mm1,mm7

 paddw mm0,mm1

 movd mm1,dword ptr [edi+esi+8]

 punpcklbw mm1,mm7

 paddw mm0,mm1

 psrlw mm0,4

 packuswb mm0,mm0

 movd dword ptr [edi],mm0

 add edi,4

 dec contpixel

 jnz linea32

 mov eax,pixelsx

 mov contpixel,eax

 add edi,incxlinea

 dec pixelsy

 jnz linea32

final:

 emms

}

}



Éste código fue enviado por fiero el 3 de noviembre del 2002

fierodeval@hotmail.com

Si quieres enviar tu propio código hazlo a eth_cotd@lycos.es

Al control treeview a mi juicio le faltan algunas funciones como CheckAll o FindItem. Para esto escribi estas funciones. Lo que hacen es simplemente ir recorriendo el control, si tienen hijos no es archivo y por lo tanto entra y busca hermanos si son carpetas(tienen hijos) se vuelve a llamar a si misma hasta que no tiene mas hijos y entonces lo chekea y se ajustan los contadores. Siempre hay que conservar el valor anterior del HTREEITEM "hElementoMem" para volver a las precesivas carpetas cuando termina la llamada a la funcion recursiva y vuelve para terminar la funcion. Observar que se declara la variable hElementoMem dentro del bucle y que cada vez que se vuelve a llamar a la funcion recursiva se crea otra nueva variable y asi indefinidamente.
Con este sistema tambien se podrian buscar cadenas de texto en los items para que por ejemplo al pulsar sobre ellos se cargue el archivo y tambien lo he usado para montar la ruta completa del mismo y asi no tener que guardar un array con las rutas completas.

PD: Supongo que vosotros esto lo tendreis mas que visto, pero si no es asi o creeis que es de interes, gustoso os mandare los otros ejemplos citados en la descripcion.

Código [Seleccionar] Expand





void CReempView::SelTodoLista()//Al cargar una lista de archivos en un treeview con checks ejecutamos esta funcion

{

 nArchTotal=0;

nArchCheq=0;

 

hElemento=m_CtrlLista.GetRootItem();

m_CtrlLista.SetCheck(hElemento);

m_CtrlLista.GetChildItem(hElemento);



RecurSelTodoLista();

}



void CReempView::RecurSelTodoLista()//Funcion recursiva

{



do{

 if(!m_CtrlLista.ItemHasChildren(hElemento))//Si no tiene hijos

 {

  m_CtrlLista.SetCheck(hElemento,bSelTodo);

  hElemento=m_CtrlLista.GetNextSiblingItem(hElemento);

  nArchTotal++;

  nArchCheq++;  

 }

 else if(m_CtrlLista.ItemHasChildren(hElemento))//Si Tiene Hijos

 {

  HTREEITEM hElementoMem;

 

  hElementoMem=hElemento;

  m_CtrlLista.SetCheck(hElemento,bSelTodo);

  hElemento=m_CtrlLista.GetChildItem(hElemento);

  RecurSelTodoLista();

  hElemento=hElementoMem;

  hElemento=m_CtrlLista.GetNextSiblingItem(hElemento);

 }

}while(hElemento!=NULL);

}







Éste código fue enviado por Antares el 28 de octubre del 2002

orionmaps@tiscali.es

Si quieres enviar tu propio código hazlo a  eth_cotd@lycos.es

En q caso usariais vosotros threads en vuestro juego ? En concreto para q partes del juego ?

saludos

Tengo una clase q se encarga de acceso a ficheros,  ejecucion de scripts, y demas cosas basicas. El problema viene a la hora de usarla, q qcreeis q es mas conveniente usarla como clase madre de todas las demas q la necesiten o hacer una instacia global de esa clase y usarla dentro de cada una de las clases.

La primera solucion me parece la mas acertada desde el punto de vist del diseño orientado a objetos, pero la segunda me parece mas eficiente.

Alguna idea?
saludos

x-alien , whiteblazier -> http://www.stratos-ad.com/forums2/viewtopic.php?t=793

   Este es un viejo código muy útil para todos aquellos que utilizan el FVF
de D3D. Al tener una estructura con muchas posibilidades, se plantea
tener un sistema fácil de acceso a las propiedades. Por ejemplo, podemos
tener mallas con Diffuse y otras que no lo tienen. Y si tienen diffuse y
queremos modificarlo directamente, necesitamos saber en qué posición de
memoria se encuentran, que despende totalmente de los FVF que se hayan
asignado para esta malla
Pues con este código, se guarda el valor del desplamzamiento en una
variable y luego se aplica donde sea conveniente. Asó el FVF se
convierte en algo transparente para el desarrollador, puesto que llama
al método EstablecerDiffuse sin preocuparle cómo está formado el FVF

¡Espero que os guste!

Código [Seleccionar] Expand





void CXMalla::EstablecerFVF(DWORD FVF,bool convertir)

{

               DWORD d;CXFVF ant;



m_FVF.FVF=FVF;

m_FVF.tamanyo=D3DXGetFVFVertexSize(FVF);

m_FVF.desp_diffuse=0;

m_FVF.desp_specular=0;



for(d=0;d<CX_MAX_MTEXT;d++) m_FVF.desp_textura[d]=0;



// Calculamos el desplazamiento en bytes



d=0;

if((FVF & D3DFVF_XYZ)==D3DFVF_XYZ) d=3*4; // 3 float

if((FVF & D3DFVF_XYZRHW)==D3DFVF_XYZRHW) d=4*4; // 4 float

if((FVF & D3DFVF_XYZB1)==D3DFVF_XYZB1) d=(3+1)*4;

if((FVF & D3DFVF_XYZB2)==D3DFVF_XYZB2) d=(3+2)*4;

if((FVF & D3DFVF_XYZB3)==D3DFVF_XYZB3) d=(3+3)*4;

if((FVF & D3DFVF_XYZB4)==D3DFVF_XYZB4) d=(3+4)*4;

if((FVF & D3DFVF_XYZB5)==D3DFVF_XYZB5) d=(3+5)*4;



if(FVF & D3DFVF_NORMAL) d+=(3)*4;

if(FVF & D3DFVF_PSIZE) d+=(1)*4;



if(FVF & D3DFVF_DIFFUSE) {

 m_FVF.desp_diffuse=d;

 d+=(1)*4;

}



if(FVF & D3DFVF_SPECULAR) {

 m_FVF.desp_specular=d;

 d+=(1)*4;

}

DWORD w,k=FVF>>D3DFVF_TEXCOUNT_SHIFT;



if(k>CX_MAX_MTEXT) k=CX_MAX_MTEXT;



for(w=0;w<k;w++) {

 m_FVF.desp_textura[w]=d;

 d+=(2)*4;

}

}



void CXMalla::EstablecerDiffuse(DWORD Diffuse,DWORD inicial,DWORD nvert)

{

CXVERTEX *dest;DWORD *diffuse,n;



if(m_FVF.desp_diffuse==0) return;



m_VB->Lock(0,0,(BYTE **)&dest,0);



// Saltamos hasta el diffuse



dest+=m_FVF.desp_diffuse;



if(nvert!=0) {

 dest+=inicial*m_FVF.tamanyo;

 n=nvert;

}

else n=m_NVertices;



while(n-->0) {

 diffuse=(DWORD *)dest;

 *diffuse=Diffuse;

 dest+=m_FVF.tamanyo;

}

m_VB->Unlock();

}





Éste código fue enviado por Drácula el sábado, 26 de octubre de 2002

dracular@ono.com

Si quieres enviar tu propio código hazlo a  eth_cotd@lycos.es

Ultimamente me han llegado varios mensajes acerca de mi firma. Realmente hay algo q no se entienda? creo q un programador de videojuegos no deberia tener problemas para saber q hace. Me han sorprendido las preguntas :_(.

saludos