Códigos bobos

https://github.com/sinayra/PlayCB

1- http://www.techspot.com/community/topics/usb-drive-or-flash-problems-how-to-cleanup-and-remove-old-usb-storage-drivers.145884/ 

2- https://www.youtube.com/watch?v=Aj7-pLaAq2c

3- http://stackoverflow.com/questions/7655471/ld-exe-cannot-open-output-file-permission-denied

g++ -s -shared -I../include *.cpp -lglfw -lopengl32 -lglu32 -oplayCB.dll -Wl,—out-implib,libplayCB.a

Ela vem setada como false.

O que acontece é o seguinte: os drivers ficam atualizando, atualizando, atualizando, num ritmo muito muito muito rápido, que algumas vezes eles esquecem que tem que colocar as coisas num padrãozinho pra sua máquina e seu opengl reconhecer as funções da glew, independente da placa de vídeo. Aí, com o glew experimental setado como true, o glew vai fazer uma busca um pouco mais rígida nessas funções que não tão bem documentadinhas.

É tipo uma festa. A glew chamou um monte de funções pra festinha de aniversário. Só que, quando a glew vai conferir na listinha de convidados quem tá na festa mesmo, ela acaba não encontrando algumas de suas funções amigas. Aí ela decide procurar debaixo da mesa e acaba encontrando as funções tímidas.

-Wall -Weffc++ -pedantic \ -pedantic-errors -Wextra -Wall -Waggregate-return -Wcast-align \ -Wcast-qual -Wchar-subscripts -Wcomment -Wconversion \ -Wdisabled-optimization \ -Werror -Wfloat-equal -Wformat -Wformat=2 \ -Wformat-nonliteral -Wformat-security \ -Wformat-y2k \ -Wimplicit -Wimport -Winit-self -Winline \ -Winvalid-pch \ -Wunsafe-loop-optimizations -Wlong-long -Wmissing-braces \ -Wmissing-field-initializers -Wmissing-format-attribute \ -Wmissing-include-dirs -Wmissing-noreturn \ -Wpacked -Wpadded -Wparentheses -Wpointer-arith \ -Wredundant-decls -Wreturn-type \ -Wsequence-point -Wshadow -Wsign-compare -Wstack-protector \ -Wstrict-aliasing -Wstrict-aliasing=2 -Wswitch -Wswitch-default \ -Wswitch-enum -Wtrigraphs -Wuninitialized \ -Wunknown-pragmas -Wunreachable-code -Wunused \ -Wunused-function -Wunused-label -Wunused-parameter \ -Wunused-value -Wunused-variable -Wvariadic-macros \ -Wvolatile-register-var -Wwrite-strings

void renderFunction(){ glClear( GL_COLOR_BUFFER_BIT ); glDrawArrays(GL_LINE_LOOP, 0, 4); glfwSwapBuffers(); }

Não importa quantos pontos você define lá na funçãozinha de CreateVBO; ele só vai renderizar os arrays que você definiu de acordo com essa função.

O primeiro argumento se refere a que tipo de geometria você vai desenhar, que podem ser:

 GL_POINTS, 

GL_LINE_STRIP, 

GL_LINE_LOOP, 

GL_LINES, 

GL_LINE_STRIP_ADJACENCY, 

GL_LINES_ADJACENCY, 

GL_TRIANGLE_STRIP,

GL_TRIANGLE_FAN, 

GL_TRIANGLES, 

GL_TRIANGLE_STRIP_ADJACENCY, 

GL_TRIANGLES_ADJACENCY 

GL_PATCHES

Ainda vou descobrir o que esse GL_PATCHES faz, o resto é bem intuitivo.

O segundo argumento é qual índice do array ele vai começar a pegar as coisas [?????]. Em geral... 0???? Parece tão óbvio que parece errado.

E o terceiro argumento é quantos índices serão gerados a cada loop. São 3 eixos + transformação, então, por enquanto, pra mim só vai 4 ali.

void TileMap::renderLayer(float parallax, int cameraX, int cameraY){ if(tileset != NULL){ for(int k = 0; k < mapLayers; k++){ for(int j = 0; j < mapHeight; j++){ for(int i = 0; i < mapWidth; i++){ if(tileMatrix[i][j][k] > -1) tileset->render(tileMatrix[i][j][k], (i * tileset->getTileWidth()) - cameraX * ((k + 1) * parallax), (j * tileset->getTileHeight()) - cameraY * ((k + 1) * parallax)); } } } } }

Então, piadinhas a parte, eu tenho esta função que manda pra função tileset renderizar cada índice da matriz montada. Mais ou menos desta forma:

tileset: ┌ ┐ └ ┘ ─ │

indice:  0 1 2 3 4 5

tilemap: 0 4 4 1

             5     5

             2 4 4 3

  tilemap na tela:

┌──┐

│     │

└──┘

Basicamente, o tilemap só manda o índice do tileset pra ele renderizar. Desta forma eu achei legal como foi montada as coisas.

Bom, naquela função que tá ali em cima, eu mando cada índice de cada tile da matriz, além da posição x e da posição y dela.

(i * tileset->getTileWidth())

Neste argumento aqui, eu pego a largura do tile e multiplico pela posição i na matriz, ou seja, a posição x dela na imagem em geral.

(Multiplicando pelo x da posição na matriz)

(Sem multiplicar pelo x da matriz)

- cameraX * ((k + 1) * parallax)

Eu subtraio pela câmera porque, quando mais a câmera anda, por exemplo, pra esquerda, mais as coisas vão para a direita, então, as coisas devem ir pro lado contrário que a câmera está se movimentando.

Este

+ 1

em

(k + 1)

é arbitrário, eu poderia ter escolhido qualquer constante que vai definir a velocidade que as coisas se movem de acordo com a camada que elas estão definidas. 

Há duas coisas que fazem a mesma coisa em HTML, mas que uso de jeito diferente:

#divisoria{ position:relative; top: 10px; left:20px; } #divisoria .titulo{ font-size: 20px; color: #FF0000; font-weight: bold; }

Eu estava usando este tutorial aqui para aprender um pouco mais sobre shaders, que, por enquanto, estou fazendo a mesma coisa que nas implementações jurássicas, só que de uma forma bem mais complicada.

Ele, assim como qualquer livro sobre OpenGL, trabalha com GLUT, que é legal pra começar até você descobrir que não precisa de todo aquele sofrimento pra inicializar coisas. Por conta disso, todo tutorial que pego desses caras eu "traduzo" pra GLFW. Coisas novas sempre são legais.

E uma coisa que descobri que inicializar contexto com GLUT é diferente de inicializar contexto com GLFW.

Pro contexto funcionar direitinho, você precisa abrir a janela. Por razões.

#define GLEW_STATIC #include <GL/glew.h> #include <GL/gl.h> #include <GL/glu.h>