Mudando de casa

Estou mudando de domínio, o novo endereço será http://www.skhaz.com/, obrigado à todos que me apoiaram publicando meu blog no blogtroll (não deixem de atualizar para o novo endereço )

A vida é um Jogo?

Desculpem-me, mais eu não pude resistir em postar quando vi essa tirinha 

[Via Cyanide & Happiness]

Lançado o Arret

  Esse ai sou eu, o alex fugindo da foto para o meio da neblina

  O Arret 0.0.1a  escrito totalmente em C++ usando Irrlicht para o cliente e o   sistema de  colisão foi implementado no servidor usando a   biblioteca fisica Newton e partes da ONE, o projeto não é novo, tem uns 3 anos, já foi até  2D usando SDL, mais informações em http://projetoarret.com.br/.

Apesar de eu não fazer parte da equipe (não por nenhum tipo de desavença, mais sim porque prefiro usar Ogre), sempre torci e ajudei o projeto, estamos esperando novas atualizações

CodeBlocks 8.02

 Recentemente formatei o pc e fui baixar o codeblocks no site e tive a  surpresa de encontrar a nova versao 8.02  disponivel, baixei ela  e  fui procurar os pacotes da nightly  build mais nao encontrei… ao  iniciar  a  instalação já notei  uma quantidade generosa de novos  plugins

 

  

Destaques

• Instalador

Nenhuma mudança significativa além de uma splashscreeen, e uma melhor organização dos diretorios

  

• Autoversioning

Bom esse foi o recurso que estava procurando à muito tempo, qual a função dele? bom… ele cria um arquivo .h que contem informações do SVN, como versão, assim você pode criar uma tela “Sobre” igual a do CodeBlocks mostrando a versão do SVN



• Changelog

Esse foi outro recurso que gostei muito



• ThreadSearch

É um sistema de busca muito eficiente, Não tem nada haver com programação paralela

Mais informações em http://www.codeblocks.org/

Meu mousepad após minha namorada ver…

Antes que vocês pensem que sou pervertido ao ponto de comprar um mousepad com esse tema, eu ganhei ele de presente de um amigo. Para quem está se perguntando, sim os seios são muito macios e evitam tendinite

Documentação da Wintermoon lançada

Finalmente e depois de muito tempo, a documentação do meu projeto Wintermoon foi lançada, versão online se encontra em http://wintermoon.sourceforge.net/wintermoondocs/index.html ou se preferir baixar a versão offline http://wintermoon.sourceforge.net/wintermoondocs.zip, ainda não está totalmente comentada pois são muitas classes, erros gramaticais, criticas e sugestões são muito bem vindas, elogios mais ainda

Eliminando o codigo Fanfarrão

Certo dia estava lendo a Easy2D, e vi uma maneira Interessante, mais não desconhecida de implementar o padrão Singleton usando o std::auto_ptr. Eu já havia me deparado com um problema ao implementar uma classe Singleton, usando os ponteiros compartilhados da boost (boost::shared_ptr) que é semelhate à std::auto_ptr porem com mais recursos., mais o compilador acusava um erro, pois o destrutor da singleton era protected, eu não poderia deixar o destrutor publico, pois qualquer um podia destruilo e minha instancia da singleton retornaria nulo, Então descobri que podederia passar um segundo parametro no construtor ou no metodo reset do shared_ptr, esse segundo parametro era o Deleter, uma classe especial para deletar o ponteiro (na verdade usava apenas o operador () da classe)., então crie uma classe generica usando template chamada Deleter e à declarava como friend da Singleton, sua implementação ficou assim

template <class T>
class Deleter
{
    public:
       void operator()(T* ptr)
       {
           if (ptr != NULL) {
               delete ptr;
               ptr = NULL;
          }
       }
};

Eu achava perfeito, e ainda podia usar nos for_each da vida, porém ainda era POG…

Uma noite, bebendo e ouvindo musica (metal!), lembrei das magicas que std::mem_fun podia fazer, e resolvi implementa-la, a cobaia foi a classe InputManager da Wintermoon, usando o metodo teardown de Mouse e Keyboard como Deleter

InputManager::Init()
{
    // ...
    mKeyboard = boost::shared_ptr<Keyboard> (new Keyboard,
                         std::mem_fun(&Keyboard::teardown));

    mMouse = boost::shared_ptr<Mouse> (new Mouse,
                         std::mem_fun(&Mouse::teardown));
}

InputManager::Shut()
{
    // reset é um membro de shared_ptr, responsavel
    // por liberar a memoria do ponteiro
    mKeyboard.reset();
    mMouse.reset();
}

// class Mouse

void Mouse::teardown()
{
    // clean up data...
}

// class Keyboard

void Keyboard::teardown()
{
    // clean up data...
}

E não é que funcionou, o codigo ficou muito mais claro, mais ainda não acabou, ainda não crie a classe Singleton dos meus sonhos, usando shared_ptr, volatile, template, NonCopyable, mais estou no caminho…

Qual a cara da sua IDE?

Qual a “cara” da sua IDE? Code::Blocks, Visual Studio, Eclipse, Code Warrior, programa em C++, Java, PHP, Asm, seja lá qual for, deixe uma foto dela aqui.

Visual Studio 2005 Pro                          Code::Blocks

                

Para upar suas fotos use o ImageShack ou qualquer outro serviço de hospedagem.

Baseado no artigo de Plinio Torres – Qual é a cara da sua área de trabalho?

Classe std::string STL no VC 6 provoca corrupção da memória

Hoje em dia se torna mais comum computadores com mais de um núcleo, esse bug afeta apenas o Microsoft Visual C++ 6.0, e pode ser um problema para quem usa ele.

Referencia Classe std::string STL provoca falhas e uma corrupção da memória em computadores com múltiplos processadores

ONE (Object-Oriented Network Engine)

ONE (Object-Oriented Network Engine)

É um projeto de minha autoria e de DarkSasori, a idea é criar uma engine para redes (similar a RakNet), Escrita em C++, usando boost.

O que já temos:

• DNS com cache
• IPAdrress
• SocketLayer (Interface)
• TCP::Socket (Implementação de SocketLayer)
• UDP::Socket (Implementação de SocketLayer)
• ServerInterface
• ClientInterface
• PeerInterface
• Thread
• ThreadGroup
• ThreadJob
• Mutex
• ScopedMutex
• NetworkInitializer
• Documentação (Doxygen)

Características:

• Cache de DNS
• Suporte a plugins (.dll ou .so), como Voice, Updater, etc

Principais plataformas alvo:

• Windows
• Linux
• MacOS
• BSD

Claro, qualquer outra plataforma que possuir sockets e threads, haverá um port da ONE!

Metas:

• Sistema de plugins usando DLL (50% feito)
• Plugin Voice, similar ao RakVoice, usando a biblioteca speex
• Compactação usando zlib, bzip2 e lzma
• Criptografia (OpenSSL ?)
• Suporte ao IPv6 (20%)

Quem já usa?

• Projeto Arret (apenas algums modulos)

Licença: LGPL 3

PS. Eu ainda não disponibilizei o download nem o SVN do projeto, pois ainda não está preparado ainda.

Um pouco mais sobre namespace

namespaces em C++ são muito poderosos não servem apenas para proteger nomes em conflitos com outras bibliotecas, nos ajudam a implementar patterns como a bridge de uma forma mais clara, alem de deixar o código mais profissional.

namespace Engine
{
  namespace Video
  {
     namespace Gui
     {
         class Window
         {
             public:
               virtual ~Window() { }
         };
     }
  }
}

Você tambem poderia escrever dessa forma

using namespace Engine;
using namespace Video;
using namespace Gui;

shared_ptr<Window> window(new Window);

ou então

using Engine::Video::Gui::Window;

shared_ptr<Window> window(new Window);

Nesse exemplo usamos muitos namespaces, é raro encontrar casos como esse, apenas encontrei na engine Irrlicht (até 3 sub namespaces) e na boost (até 5 sub namespaces), o interessante é criar um aliases para o namespace da seguinte forma

// evg é um aliases para Engine::Video::Gui
namespace evg = Engine::Video::Gui;

shared_ptr<evg::Window> window(new evg::Window);

namespace “escopado”

{
  // EVG é um aliases para Engine::Video::Gui
  namespace EVG = Engine::Video::Gui;
  shared_ptr<EVG::Window> window(new EVG::Window);
}

{
  // Graphics é um aliases para Engine::Video
  namespace Graphics = Engine::Video;
  shared_ptr<Graphics::Gui::Window> window(new Graphics::Gui::Window);
}

{
  using namespace Engine;
  using namespace Video;
  using namespace Gui;

  shared_ptr<graphics::Gui::Window> window(new graphics::Gui::Window);
}

Veja que cada namespace tem seu próprio escopo.

Como boa pratica de programação prefira declarar apenas as classes que for usar de um namespace, ao invés de declará-lo todo.

Prefira usar

using std::string;
using std::vector;
using std::map;

Ao invés de

using namespace std;

Ou melhor ainda, se você tiver um projeto que use algum namespace, no seu header principal (global.h, internal.h), assim todos as classes declaradas podem ser usadas dentro do seu namespace, sem ter que ficar usando o using

namespace Wintermoon
{
  class Root;
  class Image;
  class ImageCache;
  class EventReceiver;
  class InputManager;
  ...

  using std::string;
  using std::vector;
  using std::map;
  using std::set;
  using std::multset;

  using std::for_each;
  using std::find;

  using boost::shared_ptr;
  using boost::scoped_ptr;
}

Visual Studio 2008

Minha surpresa ao instalar o M$ Visual Studio 2008, requer o .Net instalado, mesmo optando apenas instalando os pacotes relacionados apenas ao C++. Fora a porção de gente feia que aparece durante o setup…

Carregando imagens com ou sem canal alpha

Muitos já devem ter passado por isso, como descobrir se uma imagem tem ou não o canal alpha (transparência), e como carregá-la corretamente. Eis aqui uma classe que se encarrega de carregar a imagem, e descobrir se tem ou não o canal alpha.

#include <string>
#include "SDL.h"

using std::string;


class Image
{
   public:
      Image();
      virtual ~Image();

      void load(const string& filename, bool transparent = true);

      operator SDL_Surface*() const
      {
         return m_pSurface;
      } 

   private:
      SDL_Surface* m_pSurface;
};

Vamos à implementação

#include "Image.h"


Image::Image()
: m_pImage(NULL)
{
}

Image::~Image()
{
   if (m_pImage != NULL) {
      SDL_FreeSurface(m_pSurface);
   }   
}

void Image::load(const string& filename, bool transparent)
{
   if ((m_pSurface = IMG_Load(filename.c_str())) == NULL)
   {
      throw Exception("%s", IMG_GetError());
   }

   bool hasAlpha = false;

   // Se a imagem tem 32 bits, provalvelmente
   // ela tem o canal alpha, caso contrario ela
   // não tem, e nem precissamos verificar.
   if (m_pSurface->format->BitsPerPixel == 32)
   {
      // Percorremos toda a superficie da imagem
      for (int i = 0; i < m_pSurface->w * m_pSurface->h; ++i)
      {
         Uint8 r, g, b, a;

         // Mapeamos o pixel e obtemos seus
         // respectivos valores em RGBA
         SDL_GetRGBA(((Uint32*) m_pSurface->pixels)[i],
                     m_pSurface->format, &r, &g, &b, &a);

         // Se o canal alpha for diferente de 255 (opaco)
         // então a imagem tem trasparencia
         // finalizamos o loop com o break.
         if (a != 255)
         {
            hasAlpha = true;
            break;
         }
      }
   }

   // Se a imagem tiver o canal de trasparencia
   // optimizamos ela da maneira correta.
   if (hasAlpha) {
      temp = SDL_DisplayFormatAlpha(m_pSurface);
   }

   // Caso contrario, optimizamos para uma
   // superficie sem alpha
   else {
      temp = SDL_DisplayFormat(m_pSurface);

      if (transparent)
      {
         SDL_SetColorKey(temp, (SDL_SRCCOLORKEY | SDL_RLEACCEL | SDL_HWACCEL),
             SDL_MapRGB(SDL_GetVideoSurface()->format,
             255, 0, 255));
      }
   }

   if (temp)
   {
      SDL_FreeSurface(m_pSurface);
      m_pSurface = temp;
   }
}

SDL_GetVideoSurface() Essa função retorna o ponteiro da superficie do video (a publica, e não a real), veja a documentação da SDL
para maiores informações

Veja também
Mais detalhes da estrutura interna da SDL_Surface em SDL_Surface – Introdução detalhada, de Diogo_RBG

Wintermoon no Contest da PDJ

Recentemente inscrevi meu framework Wintermoon no PDJ Contest na categoria Programação, por enquanto meu único oponente na categoria é o PSPFramework, não vejo nenhuma atualização deles há muito tempo, eles que foram minha inspiração inicial de colocar o wordpress no sourceforge e transformar o site em blog.

Desejem-me sorte

mutable, que raios é isso?

Talvez você seja como eu, viciado em usar const, mais muitas vezes nos deparamos com métodos que precisamos alterar
algum atributo dentro de um método declarado como const

class Image
{
   public:
       void Draw() const;

   private:
      std::size_t m_BlitErrorCount;
}

Vejamos esse exemplo do metodo Draw da classe Image
precisamos implementar um contador de erros do SDL_BlitSurface (sinceramente não vejo utilidade isso)

void Image::Draw() const
{
    if (SDL_BlitSurface(mSurface, NULL, Screen, rect) < 0)
    {
        m_BlitErrorCount++;
        // O compilador acusa erro na linha acima 
        // pois não podemos modificar qualquer
        // atributo dentro desse método declarado como const
    }
}

Como solucionar?

Adicione a palavra reservada mutable na declaração de m_BlitErrorCount, ficando assim:

class Image
{
    public:
        void Draw() const;

    private:
        mutable std::size_t m_BlitErrorCount;
}

Veja também

Um outro caso para o uso da mutable é na implementação do design Organizando a janela em classes, de nosso amigo Vinícius, onde temos à seguinte declaração do método draw

virtual void draw() const = 0;

Usando a palavra reservada mutable na declaração do atributo usado internamente em draw você “burla” o const

Agora seu código compila sem erros