O Cubo RGB

[thoga31]

Não é propriamente um "desafio", mas sim uma forma de podermos ver como é que as nossas linguagens de eleição trabalham com gráficos avançados. 😉

O objectivo é criar uma pequena aplicação, ou script, que crie o cubo RGB em perspectiva cavaleira.

Devemos ser capazes de ver o cubo a ser construído, ou seja, vamos vendo ele a ser criado de um lado até ao outro seguindo um dos eixos.

Exemplo:

- seguindo o eixo R, desenho os recortes do cubo, criando pouco a pouco o cubo.

Como uma imagem vale mais do que mil palavras, o objectivo é que o output vá surgindo desta forma:

O cubo poderá ter uma dimensão ao vossos gosto, apesar do aconselhável ser 256 píxeis de lado, e podem utilizar o eixo que quiserem para fazer a construção sequencial do cubo.

Não há input, só há output, o qual já foi explicado.

Qualquer LP que consiga fazer isto pode ser utilizada, e não há limites nem condições. É mesmo para usar as capacidades de cada LP para gráficos avançados.

Espero que gostem deste "desafio" - pretendi que fosse mais divertido do que "queima-miolos", para variar 😛

Cumprimentos,

thoga31.

[HappyHippyHippo]

só uma nota, não aconselho a perspectiva cavaleira (vou assumir que se refere à de 45º, mesmo que o problema se reflicta nas outras).

essa perspectiva indica que o lado deverá ter metade do tamanho real o que vai causar problemas ao nível da posição dos pixels ao avançar em Z

o melhor seria a perspectiva militar (variação da cavaleira) que indica que os lado deverão ser representados com o seu tamanho real

ps : claro que é só para simplificar ... quem resolver isto com algo como o opengl faz o que entender 😄

Edited June 26, 2012 at 03:29 PM by HappyHippyHippo

[thoga31]

A perspectiva militar não é muito fácil de ser colocada em código, apesar de uns quantos cálculos o permitirem.

A minha intenção é mesmo ver as capacidades "brutas" de cada LP nesta área, e não obter outputs todos xptos...

Claro que arte é sempre bem-vinda, mas não acho que valha muito a pena para o caso 😛

---

E como não poderia deixar de ser, eu fiz isto em Pascal recorrendo a métodos que já existem desde os anos 80.

A imagem que aqui coloquei é o output do seguinte código:

PROGRAM RGB_cubo;
USES graph;

CONST canto = 300;
     passo = 3;

VAR driver, modus : smallint;
   r, g, b : integer;

BEGIN
    DetectGraph(driver, modus);
    InitGraph(driver, modus, '');

    for r:=255 downto 0 do begin
        for g:=0 to 255 do
            for b:=0 to 255 do begin
                SetRGBPalette(20,r,g,b);
                PutPixel(g + (r div passo) + canto, b - (r div passo) + canto, 20);
            end;
        Inc(r, -passo + 1);
    end;

    SetColor(White);
    SetLineStyle(SolidLn, 0, NormWidth);
    Line(canto, canto, canto + 255, canto);
    Line(canto + 255, canto, canto + 255, canto + 255);
    Line(canto + 255, canto, canto + 255 + (255 div passo), canto - (255 div passo));

    write('FIM.'); readln;
    CloseGraph;
END.

Edited June 26, 2012 at 03:38 PM by thoga31

[pmg]

Aqui esta a minha versao em C com SDL.

#include <stdio.h>
#include <SDL/SDL.h>

#define BORDER 32

int main(void) {
 SDL_Surface *canvas = NULL;

 SDL_Init(SDL_INIT_EVERYTHING);
 canvas = SDL_SetVideoMode(640, 480, 32, SDL_SWSURFACE);
 uint32_t *pixel = canvas->pixels;

 for (int b = 0; b < 256; b++) {
   for (int r = 0; r < 256; r++) {
     int col = BORDER + 128 - b / 2 + r;
     for (int g = 0; g < 256; g++) {
       int row = BORDER + (256 - g) + (b / 2);
       pixel[row * canvas->w + col] = r + g * 256 + b * 256 * 256;
     }
   }
   SDL_Flip(canvas);
   SDL_Delay(10); /* 10 milli seconds */
 }
 puts("Press ENTER");
 getchar();
 SDL_FreeSurface(canvas);
 SDL_Quit();
 return 0;
}

Edited June 26, 2012 at 09:35 PM by pmg

[Triton]

Gráficos avançados? 😄

Edited June 27, 2012 at 05:11 AM by Triton

[thoga31]

Gráficos avançados? 😄

É a definição generalista para estes outputs.

Claro que não são "avançados" comparados com as actuais tecnologias, mas essas mesmas tecnologias não são parte integrante e nativa de muitas das LPs - o Pascal, por exemplo, pode suportar muitas dessas coisas, mas têm de ser importadas bibliotecas externas que não fazem parte nem da RTL nem da FCL, e o cubo produzido pelo meu programa é feito com capacidades que são parte integrante da RTL 😉

[mjamado]

Em JavaScript (usando o canvas da especificação HTML5):

var x, y, z, halfZ, byteIndex, ctx = document.getElementById('cnv').getContext("2d"), imd = ctx.getImageData(0, 0, 384, 384);

ctx.canvas.width = 384;
ctx.canvas.height = 384;

for (z = 0; z < 256; z += 2) {
   halfZ = Math.round(z / 2);
   for (x = 0; x < 256; x++) {
       for (y = 0; y < 256; y++) {
           byteIndex = ((383 - (y + halfZ)) * imd.width * 4 + (x + halfZ) * 4);
           if (!imd.data[byteIndex + 3]) {
               imd.data[byteIndex] = 255 - z;
               imd.data[byteIndex + 1] = x;
               imd.data[byteIndex + 2] = y;
               imd.data[byteIndex + 3] = 255;
           }
       }
   }
}

ctx.putImageData(imd, 0, 0);

Assume-se que existe um canvas na DOM, com o id "cnv". Exemplo a funcionar aqui.

Edited June 27, 2012 at 10:46 PM by mjamado