Spelprog v.2

Denna vecka har vi fått lära oss att rita ut 3D objekt! Vi har fått lära oss saker som ”Vertex, shader, buffer”.

Vertex – Vertriser, är punkter i ett objekt som har koordinater. Med vertriserna ritar  vi ut trianglar och med flera trianglar får vi ut olika 3D objekt.

Shader – När det gäller datorgrafik, är en Shader ett datorprogram som används för att göra shading: produktion av lämpliga nivåer av färg i en bild, eller, i modern tid, också att skapa specialeffekter eller göra video efterbearbetning. En definition i lekmannatermer kan ges som ”ett program som berättar en dator hur man drar något på ett specifikt och unikt sätt”.       #Wikipedia

Buffer – Bara några minnesblock. Människor tenderar att använda ordet ”buffert” när man talar om att flytta data runt, eftersom uppgifterna kommer att placeras i bufferten, placerades därefter i sin slutdestination. Det är inte alltid fallet men, men det är en av dessa ”känns rätt” programmerare saker

En vertex-buffer är: En Vertex Buffer Object (VBO) är en OpenGL funktion som ger metoder för uppladdning vertex data (position, normal vektor, färg, etc.) till videoenheten för icke-omedelbar-mode rendering. VBOs erbjuder avsevärda prestandavinster över omedelbar läge som gör främst på grund av att uppgifter finns i video enhetens minne snarare än systemminnet och det kan göras direkt av videoenheten.      #Wikipedia

 

För att rita ut något i 3D behövs tre basic grejer vilket är: Vertex-buffer, Vertex/pixel-shader, input_layout.

Med vertriserna ritar vi vi ut massa trianglar för en triangel är den minsta möjliga polynomen som har en yta. En vertris är en punkt, två är ett sträck, tre är en triangel. 

När vi ritar ut en fyrkant har vi flera olika trianglar med koordinater som utgår ifrån varandra. Två trianglar som har ligger emot varandra skapar en rektangel. Så med 36 trianglar kan man skapa en kub.
Vi ritar ut vertriserna med koordinater som x y z då x är höger och vänster, y är upp och ned, z är in och ut. Det kan se ut något som:

{ -1.0f, 1.0f, 0.0f, 0xff0000ff }, //x y z //0x = hexadecimal sen är det spegelvänt till RGBA så det blir BGRA som är BLÅ GRÖN RÖD ALPHA// Just denna triangel är röd
{ 1.0f, 1.0f, 0.0f, 0xffff0000 }, //blå
{ 1.0f, -1.0f, 0.0f, 0xff00ff00 }, //grön

{ 1.0f, -1.0f, 0.0f, 0xff00ff00 }, //grön
{ -1.0f, -1.0f, 0.0f, 0xffff00ff }, //gul
{ -1.0f, 1.0f, 0.0f, 0xff0000ff }, //röd

//——————————————-
{ 1.0f, 1.0f, 2.0f, 0xffff00ff }, //rosa
{ 1.0f, -1.0f, 0.0f, 0xff00ff00 }, //grön
{ 1.0f, 1.0f, 0.0f, 0xffff0000 }, // blå

{ 1.0f, -1.0f, 0.0f, 0xff00ff00 }, //grön
{ 1.0f, 1.0f, 2.0f, 0xffff00ff }, //rosa
{ 1.0f, -1.0f, 2.0f, 0xffffffff }, //grön
//——————————————–
{ 1.0f, -1.0f, 2.0f, 0xffffffff }, //vit etc….
{ 1.0f, 1.0f, 2.0f, 0xffff00ff },
{ -1.0f, 1.0f, 2.0f, 0x00000000 },  //svart

{ -1.0f, 1.0f, 2.0f, 0x00000000 },
{ -1.0f, -1.0f, 2.0f, 0xff00ffff },
{ 1.0f, -1.0f, 2.0f, 0xffffffff },

//———————————————
{ -1.0f, 1.0f, 0.0f, 0xff0000ff },
{ -1.0f, -1.0f, 0.0f, 0xffff00ff },
{ -1.0f, 1.0f, 2.0f, 0x00000000 },

{ -1.0f, -1.0f, 2.0f, 0xff00ffff },
{ -1.0f, 1.0f, 2.0f, 0x00000000 },
{ -1.0f, -1.0f, 0.0f, 0xffff00ff },
//———————————————
{ -1.0f, 1.0f, 0.0f, 0xff0000ff },
{ -1.0f, 1.0f, 2.0f, 0x00000000 },
{ 1.0f, 1.0f, 2.0f, 0xffff00ff },
{ 1.0f, 1.0f, 2.0f, 0xffff00ff },
{ 1.0f, 1.0f, 0.0f, 0xffff0000 },
{ -1.0f, 1.0f, 0.0f, 0xff0000ff },

//———————————————
{ 1.0f, -1.0f, 2.0f, 0xffffffff },
{ -1.0f, -1.0f, 2.0f, 0xff00ffff },
{ -1.0f, -1.0f, 0.0f, 0xffff00ff },

{ -1.0f, -1.0f, 0.0f, 0xffff00ff },
{ 1.0f, -1.0f, 0.0f, 0xff00ff00 },
{ 1.0f, -1.0f, 2.0f, 0xffffffff },

 

 

Spelprog v.1

Vi har fått uppgift att skapa en Linked List och Binärt Sökträd.

Linked List är:

En länkad lista är en dynamisk datastruktur som används inom programmering. Att den är dynamisk innebär att den enkelt kan öka och minska i storlek efter behov, till skillnad från till exempel en array, som har en fix storlek. I en länkad lista kan även element läggas till och tas bort i mitten.

En länkad lista innehåller noll eller flera noder. En nod består av två fält; ett informationsfält och ett adressfält. Informationsfältet är det data som ska sparas. Adressfältet innehåller adressen till nästa nod i listan eller ett speciellt värde, null, om det inte finns fler noder.

#Wikipedia

Binary SearchTree

Ett binärt sökträd är ett binärträd (dvs varje nod har högst två barn) med följande egenskaper:

• varje nod har ett värde.
• det högra delträdet till en nod innehåller bara värden som är högre än värdet i noden.
• det vänstra delträdet till en nod innehåller bara värden som är lägre än värdet i noden.

Binära sökträd är användbara eftersom det finns effektiva sökalgoritmer som kan användas på dem. I genomsnitt är algoritmen av ordning Θ(log n) och i värsta fall Θ(n).

#Wikipedia

Jag började med att göra Linked List men avbröt min programmering för att göra klart komplettering i spelprogrammering 2. Men det jag har gjort är:

struct Node
{
T NewNode; //Tommi sa att vi skulle utgå irån att använda int så det är vad jag tänker göra varje gång jag skapar en ny nod.
Node* FirstNode; //En pekare till första noden i listan <——–Behöver inte vara med i structen
Node* CurrentNode; //En pekare till den noden man är på <——–Behöver inte vara med i structen
Node* NextNode; //En pekare till nästa nod

};
Node* m_node;

public:
Lista()
{
//m_node = new Node();

//m_node->FirstNode = NULL;
//m_node->CurrentNode = NULL;
}
~Lista()
{

}
void AddNode(int tal1) //Lägga till en node
{
Node* node = new Node(); //Skapar en ny nod
node->NewNode = tal1; //sätter värdet på noden som man matar in i konsolen
node->NextNode = nullptr; //Går vidader till nästa element och pekar på NULL så länge
if ( node->FirstNode != NULL) // Om FirstNode hittar något att peka på
{
CurrentNode = FirstNode; //Om FirstNode pekar på något så ska den noden vi jobbar med också peka på den
while (CurrentNode->NextNode != NULL) //Kolla om vi är på slutet av listan (Så länge nuvarande noden inte är NULL)
{
CurrentNode = CurrentNode->NextNode; //När den kommer till slutet av listan så tar den det tomma utrymmet
}
CurrentNode->NextNode = node; //Efter att ha gått igenom till sista platsen i listen så sätts värdet på den nya noden
}
else //Om det är första noden kommer den skapa FirstNode som första noden
{
node->FirstNode = node->NewNode;
}

CurrentNode = node; //Sätter nästa nod till Current ifall man ska lägga till fler tal så kommer den peka vidare till nästa.
}
void DeleteNode(int tal1) //Peka på NULL deleta nod
{

}
void Testalista()
{

}

Jag vet att det är fel på mina pekare men jag har inte rättat till det än