Deferred Load ASP.NET/JQuery

img1

Hoje vou descrever uma técnica de como carregar o conteúdo  dinâmico após a pagina ser carregada, isso pode aumentar bastante a experiência com o usuário se você tem que exibir uma quantidade grande de dados, ou pegar algum conteúdo de um servidor externo. A técnica consiste em baixar todo o conteúdo estático, e após o documento estar pronto (ready), fazer uma requisição em AJAX para baixar o conteúdo dinâmico.

Temos dois exemplos um pegando o conteúdo de RSS e montando uma lista via javascript, no segundo caso que renderiza o HTML é um WebControl contendo um Repeater, então vamos para o código.

Antes de mais nada crie um novo projeto Web e monte o mesmo com a estrutura abaixo.

O  FeederLoader.cs representa o Proxy entre a fonte de dados e a requisição AJAX, nela usamos o WebClient para baixar um RSS e devolvemos para o navegador, e o código dela e este:

public class FeederLoader
{
    public FeederLoader()
    {
    }

    public string Load(string url)
    {
        WebClient client = new WebClient();
        byte[] buffer = client.DownloadData(url);

        return UTF8Encoding.UTF8.GetString(buffer);
    }

O método Load baixa o conteúdo da url usando o WebClient e devolve como uma String UTF-8.
Partimos agora para o Handler FeederJS.ashx

public void ProcessRequest (HttpContext context) {
        context.Response.ContentType = "text/xml";
        FeederLoader Loader = new FeederLoader();
        
       System.Threading.Thread.Sleep(1000); //só pra ficar cool

        string rss = Loader.Load("http://newbie-x11.blogspot.com/feeds/posts/default?alt=rss");
        context.Response.Write(rss);
        context.Response.End();
        
    }

No método ProcessRequest usamos o FeederLoad pra baixar o RSS deste blog :-] , e devolver para o XML navegador.
Agora a página Web, EmJavaScript.aspx

<style type="text/css">
        
        .Loading
        {
            background-image: url('images/loader.gif');
            background-repeat:no-repeat;
        }
        
    </style>

  <div id="master">
            <div id="static">
                Como as vezes tenho uma alta enorme de creatividade não vou escrever nada aqui.
            </div>
            <div id="dynamic">
            </div>
        </div>
        <div>

            <script type="text/javascript" src="js/jquery-1.3.2.min.js"></script>
            <script type="text/javascript">
            $(document).ready(function(){
            var ajaxOption = {
                        type: "GET",
                        url: "handlers/FeederJS.ashx",
                        dataType : "xml",
                        success : function(data){
                            var html = "<ul>"
                            $(data).find('item').each(function(){
                                var titulo = $(this).find('title').text();
                                html += "<li>"+titulo+"</li>";
                            });
                            
                            html += "</ul>";
                            
                            $("#dynamic").append(html);
                            $("#dynamic").attr("class","");
                        }
                    };
                    
                    $("#dynamic").attr("class","Loading");
                    
                    $.ajax(ajaxOption);
                    
            });
            
          
            </script>

        </div>

Acima antes de fazer a requisição em AJAX , mudamos o CSS do elemento que abriga o conteúdo dinâmico para a classe que contem a imagem carregando, na Requisição (success), fazemos o loop no xml e montamos uma lista, preenchemos o conteudo carregado no elemento, e removo a classe de CSS .Loading, e Badabum..

Agora se você não quer ficar montando conteudo via JavaScript demonstro abaixo com poucas modificações, fazemos a mesma coisa só que usando o um Repeater e um User Control, vamos lá crie o Controle, então adicione um novo Web User Control com o nome de Listageml.ascx, e o código dele segue abaixo.

<%@ Control Language="C#" AutoEventWireup="true" CodeFile="Listageml.ascx.cs" Inherits="controles_Listageml" %>
<div>
    <asp:Repeater ID="Repeater1" runat="server">
        <HeaderTemplate>
            <ul>
        </HeaderTemplate>
        <ItemTemplate>
            <li>
                <%# Eval("title") %>
            </li>
        </ItemTemplate>
        <FooterTemplate>
            </ul></FooterTemplate>
    </asp:Repeater>
</div>

O .cs:

protected void Page_Load(object sender, EventArgs e)
    {
        XmlTextReader reader = new XmlTextReader("http://g1.globo.com/Rss2/0,,AS0-5597,00.xml");

        DataSet ds = new DataSet();

        ds.ReadXml(reader);
        Repeater1.DataSource = ds.Tables["item"];
        Repeater1.DataBind();
    }

Creio que não seja necessário comentar o bloco acima, agora vamos ao Handler FeederASP.ashx, que tem modificações significativas:

public void ProcessRequest (HttpContext context) {
        
        Page page = new Page();
        UserControl ctl = (UserControl)page.LoadControl("~/controles/Listageml.ascx");
        StringWriter writer = new StringWriter();

        System.Threading.Thread.Sleep(1000); //só pra ficar cool
        
        page.Controls.Add(ctl);
        HttpContext.Current.Server.Execute(page, writer, false);

        context.Response.ContentType = "text/plain";
        context.Response.Write(writer.ToString());
        context.Response.End();
    }

Acima usamos estas linhas malucas para renderizar o HTML do controle, se tiver a necessidade de passar parâmetros para o controle pode usar os atributos, mas compensa dar um passeio pelo Google e ler sobe WebControls.
Passamos agora para o arquivo EmASP.aspx, a única mudança é no Java script:

<script type="text/javascript">
            $(document).ready(function(){
            var ajaxOption = {
                        type: "GET",
                        url: "handlers/FeederASP.ashx",
                        dataType : "text",
                        success : function(data){
                         
                            
                            $("#dynamic").append(data);
                            $("#dynamic").attr("class","");
                        }
                    };
                    
                    $("#dynamic").attr("class","Loading");
                    
                    $.ajax(ajaxOption);
                    
            });
</script>

Simplificou bastante, aqui só pegamos o conteúdo pronto e colocamos no elemento.
Pronto é isso, pode baixar o código fonte aqui.

Posted in Uncategorized Tagged with: , , ,

Terreno Parte 2

Depois de algumas xícaras de café, algumas horas no parque do ipirangacom um caderno uma caneta e minha calculadora HP 9s, consegui gerar um terreno no minimo decente mais ainda fanta muita coisa, corrigi os problemas de collisão,agora os objetos colliden corretamente inclusive com o terreno.nos proximos dias estarei me divertindo montando uma classe de veiculo.

Posted in Uncategorized Tagged with: ,

Engine de Terreno

Terreno1

Olá pessoal comecei a codar o modulo de terreno na engine, o que fiz até agora
foi gerar uma malha de terreno e gerar os triangulos a partir dela, o próximo
passo é pegar todos esses vertices indexar gerar um Mesh para o ODE,
eu já podia e separar a Classe de Mesh assim o loader de wavefront,
e o mesh de terreno podem ser interpretados da mesma maneira para o ODE.

Vale apena fazer um observação sobre a elegancia da geração atual da imagem.

int offset = w*y+x;
index[offset] = offset;
grid[offset].x = x*scale;
grid[offset].z = y*scale;
grid[offset].y = sinf(x/2)*3;

Vai lá no sf e pega a última versão.
https://sourceforge.net/projects/newbie-engine/files/

Posted in Uncategorized Tagged with: ,

Socket em *NIX

Tirei esse do fundo do báu, os dos HD’s se prefirir e datado de 05/2005 e eu fiz pro grupo União Atlantica, e um código comentado que serve como tutorial, ele mostra como estabelecer conexão cliente-servidor usando sockets em *NIX creio que não funcione no windows.

****Cliente***


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>

int main(int argc,char *argv[])
{
int TSocket;
struct sockaddr_in servidor;
char msg[17] = "Uniao Atlantica";
//inicia o socket
//nota parametro 1 tipo familia do socke
//pode ser AF_INET (ARPA INTERNET PROTOCOLOS) "mais usada"
//"" AF_UNIX (UNIX INTERNET PROTOCOLOS)
//"" AF_ISO (ISO PROTOCOLOS)
//"" AF_NS (XEROX NETWORK SYSTEM PROTOCOLOS)

//nota parametro tipos SOCK_STREAM = TCP, SOCK_DGRAM = UDP
//terceiro parametro 0 (faleremos depois)
TSocket = socket(AF_INET,SOCK_STREAM,0);

if (TSocket < 0) //simples checagem de erro
{
printf("Erron");
exit(0);
}

//montando a estrutu servidor essa estrutura mas TSocket vao fazer a conecao
//entre o nosso cliente e o servidor

//estrutura sockaddr_in
//struct sockaddr_in {
//short int sin_family; { do endreco (ex: AF_INET)}
//unsignet short int sin_port; (numero da porta)
//struct sin_addr in_addr; (ip do host)
//unsignet char sin_zero[8]; (zera a estrutura)
//}

servidor.sin_family = AF_INET;
servidor.sin_port = htons(3506); //porta que vamos usar
//o htons significa host to network short
//mais info (man pages)
servidor.sin_addr.s_addr = inet_addr("127.0.0.1"); //ip destino
bzero(&(servidor.sin_zero),8); //zera o resto da estrutura

//agora a funcao connect essa funcao faz a conecao com o servidor
if (connect(TSocket,(struct sockaddr *)&servidor,sizeof(servidor)) < 0)
{
printf("erro ao fazer a conexaon");
exit(0);
}

//agora vamos usar vamos enviar uma mesnsagem para o servidor
//usnado a funcao send();
//prototipo
//int send(int TSocket,const void *msg,int size_t len,int flags)

send(TSocket,&msg,sizeof(msg),0);

//agora fechamos nosso cliente
close(TSocket);
//bom Daniel pela experiencia que voce tem com redes acho q deu pra entender tudo ate agora
//vc manja mais de ingles que eu e esse seu debian ta lotado de man pages
//qualquer coisa psota sua msg pro grupo ou pra min que a gente resolve
//pra compilar gcc cliente.c -o cliente
//executar ./cliente
return 0;
}

****Servidor.c****


//o que tem de novo aki e sao a funcoes bind() e listen()
//a funcao bind associa um socket ao nosso servidor local (eu numca entendi isso direita mas fazer o que)
//a funcao listem faz nosso servidor esperar uma conecao faz ele escutar
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <errno.h>
#include <signal.h>

int main(int argc,char *argv[])
{
int TSocket,Clientes[5],tamanho;
struct sockaddr_in local,cliente[5];
int Count,Next =0;
char *recived_msg; //cinco strings para evitar que um dois processos filhos tentem escrever a mesmo tempo
int Atual[5]; //tb uma pra cada um
//vamos setar a estrutura local com infomacoes da nossa maquina
TSocket = socket(AF_INET,SOCK_STREAM,0);

local.sin_family = AF_INET;
local.sin_port = htons(3506);
local.sin_addr.s_addr = INADDR_ANY; //enderco local
bzero(&(local.sin_zero),8);

//usar o misterioso bind
bind(TSocket,(struct sockaddr *)&local,sizeof(struct sockaddr));

//agora a funcao listem ela e bem simple
listen(TSocket,5); //o segundo parametro 5 e o numero de conexoes que vamos esperar (max)
tamanho = sizeof(struct sockaddr_in);
while (Next < 5)
{
if ((Clientes[Next] = accept(TSocket,(struct sockaddr *)&cliente[Next],&tamanho)) < 0)
{
printf("Erron");
exit(0);
}
else
{
printf("Cliente se conectou numero: %d, ip:%sn",Next,inet_ntoa(cliente[Next].sin_addr));
if (!fork())
{
int coisa = Next;
while(1)
{
if (recv(Clientes[coisa],recived_msg,20,0) < 0)
{
printf("Erro ao receber msgn");
exit(0);
}
else
{
printf("Msg Recebida:%sn",recived_msg);
exit(0);
}
}

}
Next++;
}
}
}
//o fork que faz o bicho pegar o resto nem e divertido
//imagine nosso servidor tendo que segurar 50 conexoes
//ai a conexao de algum kra anda bem lenta se o as nossas
//checagens ficassem todas num loop ia atrapalhar o andamento
//de todo servidor por isso criamos um novo processo com o fork
//ele se comunica com o pai claro mas a coisa nao e tao simples
//assim agora vou escrever um aplicativo interativo pra ser jogado
//entre no minimo 3 pessoas um servidor e dois clientes
////pra gente testar todas as singularidades espero
//que essa parte da trasnmissao ja lhe seja util de algo
//qualquer coisa sabe como me encontrar
//comando pra compilar $gcc servidor.c -o servidor
//mais uma coisa isso nao ta funcionando corretamente
//pois c os 5 servidores tiverem conectados ao mesmo tempo
//ele so vai ler o Next que e cinco isso e um problema com
//o fork que eu to tentando resolver eu queria uma fariavel
//que so fosse assecivel pelo processo filho atraves do PID..

particularmente prefiro o SDL_net é multiplataforma e mais simples de se usar.
nem estou pensando em multiplayer agora, só to publicando o que ta no bau.

Posted in Uncategorized Tagged with:

A Quantas anda a Engine

PixelLigth

Venho trazer noticias do que ando aprontando com a engine, primeiro tive um grande martirio tentando implementar os shaders mas bem após horas cansativas escrevendo coisas como

!!ARBvp1.0 “
PARAM mvp[4] = { state.matrix.mvp }
PARAM yellow = {1.0,1.0,0.0,0.0};
OUTPUT outPosition = result.position;
MOV result.color, vertex.color;
DP4 outPosition.x, mvp[0], vertex.position;
DP4 outPosition.y, mvp[1], vertex.position;

Sem debug, sem nem mesmo um analisador lexico para mostrar onde estão os erros, foram horas divertidas eu diria mas enfim estudei as equações do Dr. Phong e implementei algo deveria ser um Per Pixel Ligthing

Tambem fiz modificações no que é pra ser um Sistema de Particulas temos a representação de uma Explosão classe Explosion que é Herdeira de ParticleSystem e enfim comecei a criar a classe ParticleManager, imaginem um bombardeiro de um B-52 a cada bomba que geraria uma explosão, adicionariamos uma instancia de Explosion a ParticleManager e ela gerenciaria os sistemas.

Agora estou pensando em um terreno não tenho mais como fugir das joints do ODE e de um gameplay.

O diagrama de classe nem todas estão implementadas.

Nas próximas semanas atualizo o SVN.

Posted in Uncategorized Tagged with:

AJAX + JQuery II

Tabela

Olá pessoal, nesse tutorial vamos usar Ajax para consumir Web Services, no exemplo demonstrado temos uma classe de acesso a dados para fazer o cadastro e a listagem no banco de dados que é um uma database .mdf do SQL Server Express 2005, o Web Service é utilizado como Proxy com a classe de acesso a dados. Consumimos Web Services por javascript através de uma classe chamada SoapClient ela e de autoria de Matteo Casati , mas tive que dar uma pequena hackeada nela pois a mesma não funcionava no FireFox (ao menos no meu).
Agora vamos ao trabalho Crie um novo Web site, no diretório AppData adicione um SQL Database File, de o nome de Contatos.mdf. adicione a tabela abaixo.

O campo id é a chave primaria com auto increment, nome é varchar(50) e telefone varchar(15). Adicione Tb uma procedure para cadastrar e outra para listagem, segue o código das mesmas. Cadastro


CREATE PROCEDURE dbo.usp_insereContato

(
@nome varchar(50),
@telefone varchar(15)
)

AS
insert into Contatos (nome,telefone) values (@nome,@telefone)
RETURN

Listagem


CREATE PROCEDURE dbo.usp_listagemContatos
AS
select id,nome,telefone from Contatos
RETURN

Essas são as procedures nada de mirabolante dispensa comentários, sem seguida a classe em .cs que representa um contato


using System;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
using System.Web;
using System.Collections.Generic;
/// <summary>
/// Summary description for Contato
/// </summary>

[Serializable]
public class Contato
{
private int id;

public int Id
{
get { return id; }
set { id = value; }
}
private string nome;

public string Nome
{
get { return nome; }
set { nome = value; }
}
private string telefone;
public string Telefone
{
get { return telefone; }
set { telefone = value; }
}

public Contato(string nome, string telefone)
{
this.nome = nome;
this.telefone = telefone;
}
public Contato()
{

}
public static List<Contato> Listar()
{
List<Contato> contatos = new List<Contato>();
using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString))
{
SqlCommand command = new SqlCommand();
command.Connection = connection;
command.CommandType = System.Data.CommandType.StoredProcedure;
command.CommandText = "usp_listagemContatos";


connection.Open();
SqlDataReader dr = command.ExecuteReader();
while (dr.Read())
{
Contato contato = new Contato();
contato.id = Convert.ToInt32(dr["id"]);
contato.nome = Convert.ToString(dr["nome"]);
contato.telefone = Convert.ToString(dr["telefone"]);
contatos.Add(contato);
contato = null;
}

connection.Close();
}

return contatos;
}

public static bool Cadastrar(string nome, string telefone)
{
try
{
using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString))
{
SqlCommand command = new SqlCommand();
command.Connection = connection;
command.CommandType = System.Data.CommandType.StoredProcedure;
command.CommandText = "usp_insereContato";
command.Parameters.Add(new SqlParameter("@nome", nome));
command.Parameters.Add(new SqlParameter("@telefone", telefone));

connection.Open();
command.ExecuteNonQuery();
connection.Close();

return true;
}
}
catch
{
return false;
}
return false;
}
}

Logo acima temos propriedades com o nome e o telefone logo em seguida um método de cadastro e listagem, adicione esta classe no diretório APP_CODE com o nome Contato.cs Passamos agora para o Web Service é a parte mais graciosa da coisa toda realmente lindo adicione um novo Web Service e batize o mesmo de wsContatos.asmx e adicione os dois métodos abaixo


[WebMethod]
public bool Cadastrar(string nome, string telefone)
{
return Contato.Cadastrar(nome, telefone);
}

[WebMethod]
public List<Contato> Listar()
{
return Contato.Listar();
}

Perceberam com os métodos são simples basicamente são uma ponte ou Proxy, para a camada de negócios (sei que não temos uma camada de negócios mais esta é a idéia), o motivo que coloquei o [Serializable], neste caso nossos atributos públicos são automaticamente convertidos para um XML válido para a resposta do Web Service a resposta gerada é esta:


<?xml version="1.0" encoding="utf-8" ?>
<ArrayOfContato xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://tempuri.org/">
<Contato>
<Id>1</Id>
<Nome>Gabriel</Nome>
<Telefone>123456</Telefone>
</Contato>
<Contato>
<Id>2</Id>
<Nome>Chuck Norris</Nome>
<Telefone>666</Telefone>
</Contato>
<Contato>
<Id>3</Id>
<Nome>Shaolin Monk</Nome>
<Telefone>999</Telefone>
</Contato>
<Contato>
<Id>4</Id>
<Nome>Grande Cã</Nome>
<Telefone>777</Telefone>
</Contato>
</ArrayOfContato>

Lindo não? Agara vamos para o aspx você vai precisar do SoapClient do italiano maluco, a versão que eu fiz uma pequena modificação se encontra aqui mas primeiro adicione os controles HTML


<div>
<label>
Nome:</label><span><input type="text" id="txtNome" /></span><br />
<label>
Telefone:</label><input type="text" id="txtTelefone" /><br />
<div>
<span>
<input type="button" id="btnCadastrar" value="Cadastrar" onclick="CadastraContato();"/>
</span><span>
<input type="button" id="btnListar" value="Listar" onclick="Listar()" /></span>
</div>
<div id="listagem">

</div>
</div>

GO Javascript:


<script type="text/javascript" src="soapclient.js"></script>

<script type="text/javascript">
function CadastraContato()
{
var nome = document.getElementById('txtNome').value;
var telefone = document.getElementById('txtTelefone').value;

var parametros = new SOAPClientParameters();
parametros.add('nome',nome);
parametros.add('telefone',telefone);

SOAPClient.invoke("wsContatos.asmx", "Cadastrar", parametros, true, function (data){

if (data == true)
{
alert('Contato Cadastrado com sucesso');
}
else
{
alert('Houve um problema ao cadastrar o contato');
}

});

}

O que cada coisa faz
var parametros = new SOAPClientParameters();
este instancia o objeto responsável de guardar a lista de parâmetros para nossa chamada
parametros.add(‘nome’,nome);
parametros.add(‘telefone’,telefone);
adiciona os parametos .add(nome,valor) a lista de parâmetros (nossa!)
SOAPClient.invoke(“wsContatos.asmx”, “Cadastrar”, parametros, true, function (data){
Invoke(url,método,parâmetros,sicrono/asincrono,callback)
Eu recebo a resposta de confirmação em data o response na verdade
Passamos paro o listar


function Listar()
{
SOAPClient.invoke("wsContatos.asmx", "Listar", new SOAPClientParameters(), true, function (data){

var count = data.length;
var html = "";
for (i = 0;i < count ; i++)
{
html += "<span> Nome: "+data[i].Nome+" Telefone: "+data[i].Telefone+"</span><br/>";

}

var dv = document.getElementById('listagem');
dv.innerHTML = html;

});

}

Aqui eu Invoquei o método listar o SOAPClient me retornou uma coleção de objetos contendo os contatos, ai tem for e um HTML tosco, badabum a mágica esta pronta e é isso espero que seja útil. Você pode fazer o download do código do tuto aqui.

Posted in Uncategorized Tagged with: , ,

Newbie Engine 0.2 Now

slackDeskop4_

Bom pessoal acabei de fazer o commit no svn depois de 5 meses, tem bastante código novo lá.

http://newbie-engine.svn.sourceforge.net/viewvc/newbie-engine/

só tenho que mudar o Makefile pra compilar a nova versão (Estou trabalhando com eclipse CDT agora). e tb criar um versão pro Dev-C++ mais isso fica pro próximo RC.

temos mais um membro no projeto Geison Munhoz, ele vai se aventurar na parte de
Audio, não sei se vai dar tempo mais mais ainda estamos na GPC 08 a PDJ.

Posted in Uncategorized Tagged with:

Numeros Imaginarios

imaginario

Foi assim que me senti.

Posted in Uncategorized Tagged with:

JQuery + Ajax Parte I

xml

Olá galera neste post vou demostrar como fazer uma chamada AJAX com auxílio da JQeury, no Visal Studio 2005.

Primeiro crie um novo WebSite e adicione ao mesmo um Generic Handler, o generic handler é uma classe do que implementa o IHttpHandler, até que a expreriência me prove o contrário este recurso me parece perfeito pra trabalhar com AJAX, nela implementamos o método ProcessRequest.

public void ProcessRequest (HttpContext context) {

        context.Response.ContentType = "text/plain";
context.Response.Write("Hello World");

}

no HttpContext temos Request e um Response (HTTP), já se mostrou util desde retornar

resultados plain text, como também um gerador de thunbnail.

Vamos por a mão na massa, para deixar o tutorial mais interessante vamos receber através da request.QueryString um nome fazer uma consulta em xml e retornar o nome o telefone ao cliente então adicione o arquivo

ao seu WebSite

 

o método ProcessRequest ficará assim.
public void ProcessRequest (HttpContext context) {
HttpResponse response = context.Response;
HttpRequest request = context.Request;
XmlDocument doc = new XmlDocument();
doc.Load(request.MapPath(“contatos.xml”));
XmlNode node = doc.SelectSingleNode(string.Format(“/contatos/contato[nome = ‘{0}’]”,request.QueryString[“nome”]));
response.ContentType = “text/plain”;
response.Write(node.ChildNodes[1].InnerXml);
response.End();

}

agora no vá para defualt.aspx
mas antes vá em http://code.google.com/p/jqueryjs/ baixe a ultima versão e adicione ao seu Default.aspx

o código seria este.


creio que a única coisa digna de comentário seja

$.get(‘Handler.ashx’,{nome : _nome},function(data)
{

alert(data);

});

$.get faz uma chamada para handler.ashx passa nome como QueryString, quando recebe o retorno chama a function(data){} (data é o que ele recebeu).

você pode fazer o download do código fonte aqui.

http://br.geocities.com/newbie_x11/AJAX_I.zip

espero que tenha gostado até mais.

Sabe este editor do blogspot é norjento, desculpe pela má formatação, mas espero que tenha gostado.

Posted in Uncategorized Tagged with: , ,

Nova versão no forno

andei codadando um pouco nos últimos tempos, o que está por vir:
-Texturas
-Shader (ARB_vertex_program/ARB_fragment_program)
-Sistema de Particulas
-e uma primeira simulação como demo de técnologia

creio que a partir desse ponto vou trabalhar um pouco no contest da PDJ.

Posted in Uncategorized