Pokaż wiadomości

Ta sekcja pozwala Ci zobaczyć wszystkie wiadomości wysłane przez tego użytkownika. Zwróć uwagę, że możesz widzieć tylko wiadomości wysłane w działach do których masz aktualnie dostęp.


Wiadomości - Pawel1503

Strony: 1 ... 31 32 33 34 [35]
511
Szkółka / Odp: Sprawdzanie odległości
« dnia: Grudzień 20, 2009, 19:45:09 »
Widze że mam kolejne błędy:

1>main.cpp(33): error C2365: 'y1' : redefinition; previous definition was 'function'
1>          C:\Program Files\Microsoft Visual Studio 10.0\VC\include\math.h(470) : see declaration of 'y1'
1>main.cpp(586): error C2296: '-' : illegal, left operand has type 'double (__cdecl *)(double)'

512
Szkółka / Odp: Sprawdzanie odległości
« dnia: Grudzień 20, 2009, 19:27:01 »
może coś takiego :

Kod: (cpp) [Zaznacz]
float x1, x2, y1, y2;
a może zamiast float czy int coś innego ???

513
Szkółka / Odp: Sprawdzanie odległości
« dnia: Grudzień 20, 2009, 18:07:02 »
Ja wiem :) dlatego chce wyprzedzić nauke w gimnazjum i wiedzieć co więcej :)

514
Szkółka / Odp: Sprawdzanie odległości
« dnia: Grudzień 20, 2009, 18:04:09 »
Więc tak:

skonstruowałem coś takiego:

zmienne:
Kod: (cpp) [Zaznacz]
int odl = 0;
float x1 = 1;
float x2 = 1;
float y1 = 2;
float y2 = 2;

i dalej:

Kod: (cpp) [Zaznacz]
odl=sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
i spróbowałem skompilować ale wyświetla mi takie dwa błędy:

1>main.cpp(586): error C2296: '-' : illegal, left operand has type 'double (__cdecl *)(double)'
1>main.cpp(586): error C2296: '-' : illegal, left operand has type 'double (__cdecl *)(double)'


A tak na marginesie to chodze do 1 gimnazjum i pewnie dlatego jestem taki ciemny z tego :(

//wiem co to jest a, b, c :)


515
Szkółka / Odp: Sprawdzanie odległości
« dnia: Grudzień 18, 2009, 23:50:17 »
Ja tez sie z tego cieszę. Chociaż szczerze mówiąc to jestem przerażony moja niewiedzą. Co prawda niby przerabiam te moja ksiazke ale...

516
Szkółka / Odp: Sprawdzanie odległości
« dnia: Grudzień 18, 2009, 22:34:20 »
Jeśli chodzi o przechowywanie czegoś w zmiennej to napisałem tylko jako w dopełnieniu bo takie coś już umiem.

Rm-f: błagam, nie wściekaj sie na mnie, nie jestem w zaawansowanym stadium nauki

517
Szkółka / Sprawdzanie odległości
« dnia: Grudzień 18, 2009, 22:27:12 »
Mam kolejne pytanie:

jak to napisać żeby uzyskać odległość między jednym, a drugim sześcianem, a potem przechowywać to w jakiejś zmiennej ???

Pozdrawiam !

518
Szkółka / Odp: Kolizje obiektów 3D
« dnia: Grudzień 18, 2009, 22:23:43 »
Ok spróbuje coś wykombinować - jak coś wymyśle to dam znać.

Dzięki za pomoc !!!

519
Szkółka / Odp: Kolizje obiektów 3D
« dnia: Grudzień 18, 2009, 21:25:42 »
Hmm to ma wyglądać tak:

mamy np. 2 sześciany. Chciałbym żeby gdy jeden z boków pierwszego sześcianu zderzył się z np. drugim bokiem drugiego sześcianu to jakaś zmienna dałaby wartość TRUE.

520
Szkółka / Odp: Kolizje obiektów 3D
« dnia: Grudzień 18, 2009, 20:57:01 »
Rozumiem, ale ja nie umiem właśnie czegoś takiego zrobić :(

Czy może mi ktoś dać kod odpowiedzialny za to, albo dać linka do jakiegoś  tutoriala  ??? Może być nawet angielski bo z tego co wiem to Polskiego się nie znajdzie  :-\

//edit// czy ten kawałem kodu który dałem powyżej może się do czegoś przydać ?

521
Szkółka / Kolizje obiektów 3D
« dnia: Grudzień 18, 2009, 18:40:28 »
Jest to mój pierwszy post więc witam wszystkich !!!

Programuje w c++, na bibliotece OpenGL. Mam taki problem z kolizjami bo nie wiem jak je zrobić. W mojej książce znalazłem sposób wykrywania kolizji płaszczyzn. Widniał też taki kod:

Kod: (cpp) [Zaznacz]
#define TWOPI 6.283185307179586476925287
#define RADTODEG 57.2957795
#define TOLERANCE 0.0000001

bool PointInPolygon(CVector p, CVector *points, int numPoints)
{
CVector segment1, segment2;
double length1, length2;
double sumAngles = 0.0f;
double cosAngle = 0.0f;

for(int idx = 0; idx < numPoints; idx++)
{
segment1 = points[idx] - p;
segment2 = points[(idx + 1) % numPoints] - p;

if (segment1.Length() * segment2.Length() <= TOLERANCE)
{
sumAngles = TWOPI;
break;
}
cosAngle = (segment1 % segment2) / (segment1.Length() * segment2.Length());
sumAngles += cos(cosAngle);
}
if ((sumAngles <= (TWOPI + TOLERANCE)) && (sumAngles >= (TWOPI - TOLERANCE)))
return true;
else
return false;
}

Wcześniej napisałem program który wyświetla 2 oteksturowane sześciany. Wygląda on tak
Kod: (cpp) [Zaznacz]
#define WIN32_LEAN_AND_MEAN


////// Definicje
#define BITMAP_ID 0x4D42
#define TWOPI 6.283185307179586476925287
#define RADTODEG 57.2957795
#define TOLERANCE 0.0000001


////// Pliki nagłówkowe
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glaux.h>
#include <Plane.h>

////// Zmienne globalne
HDC g_HDC;
bool fullScreen = false;
bool keyPressed[256];
float angle = 0.0f;
double ruchprzod = 0;
double ruchbok = 0;
double ruchgora = 0;




////// Opis tekstury
BITMAPINFOHEADER bitmapInfoHeader; // pomocniczy nagłówek obrazu
BITMAPINFOHEADER landInfo; // nagłówek obrazu tekstury lądu
BITMAPINFOHEADER waterInfo; // nagłówek obrazu tekstury wody

unsigned char* imageData; // dane mapy
unsigned char*      landTexture; // dane tekstury lądu
unsigned char* waterTexture; // dane tekstury wody
unsigned int land; // obiekt tekstury lądu
unsigned int water; // obiekt tekstury wody

float ambientLight[] = { 0.5f, 0.5f, 0.5f, 1.0f }; // światło otoczenia
float diffuseLight[] = { 0.5f, 0.5f, 0.5f, 1.0f }; // światło rozproszone
float specularLight[] = { 1.0f, 1.0f, 1.0f, 1.0f }; // światło odbicia

float spotlightPosition[] = { 6.0f, 0.5f, 0.0f, 1.0f }; // położenie źródła strumienia światła
float spotlightDirection[] = { -1.0f, 0.0f, -1.0f }; // kierunek strumienia światła

////// Zmienne materiału
float matAmbient[] = { 1.0f, 1.0f, 1.0f, 1.0f }; // dla światła otocznenia
float matDiff[] = { 1.0f, 1.0f, 1.0f, 1.0f}; // dla swiatła rozproszonego
float matSpecular[] = { 1.0f, 1.0f, 1.0f, 1.0f }; // dla światła odbicia





bool PointInPolygon(CVector p, CVector *points, int numPoints)
{
CVector segment1, segment2;
double length1, length2;
double sumAngles = 0.0f;
double cosAngle = 0.0f;

for(int idx = 0; idx < numPoints; idx++)
{
segment1 = points[idx] - p;
segment2 = points[(idx + 1) % numPoints] - p;

if (segment1.Length() * segment2.Length() <= TOLERANCE)
{
sumAngles = TWOPI;
break;
}
cosAngle = (segment1 % segment2) / (segment1.Length() * segment2.Length());
sumAngles += cos(cosAngle);
}
if ((sumAngles <= (TWOPI + TOLERANCE)) && (sumAngles >= (TWOPI - TOLERANCE)))
return true;
else
return false;
}






// LoadBitmapFile
// opis: ładuje mapę bitową z pliku i zwraca jej adres.
//       Wypełnia strukturę nagłówka.
// Nie obsługuje map 8-bitowych.
unsigned char *UstawieniaBitmapy(char *filename, BITMAPINFOHEADER *bitmapInfoHeader)
{
FILE *filePtr; // wskaźnik pozycji pliku
BITMAPFILEHEADER bitmapFileHeader; // nagłówek pliku
unsigned char *bitmapImage; // dane obrazu
int imageIdx = 0; // licznik pikseli
unsigned char tempRGB; // zmienna zamiany składowych

// otwiera plik w trybie "read binary"
filePtr = fopen(filename, "rb");
if (filePtr == NULL)
return NULL;

// wczytuje nagłówek pliku
fread(&bitmapFileHeader, sizeof(BITMAPFILEHEADER), 1, filePtr);

// sprawdza, czy jest to plik formatu BMP
if (bitmapFileHeader.bfType != BITMAP_ID)
{
fclose(filePtr);
return NULL;
}

// wczytuje nagłówek obrazu
fread(bitmapInfoHeader, sizeof(BITMAPINFOHEADER), 1, filePtr);

// ustawia wskaźnik pozycji pliku na początku danych obrazu
fseek(filePtr, bitmapFileHeader.bfOffBits, SEEK_SET);

// przydziela pamięć buforowi obrazu
bitmapImage = (unsigned char*)malloc(bitmapInfoHeader->biSizeImage);

// prawdza, czy udało się przydzielić pamięć
if (!bitmapImage)
{
free(bitmapImage);
fclose(filePtr);
return NULL;
}

// wczytuje dane obrazu
fread(bitmapImage, 1, bitmapInfoHeader->biSizeImage, filePtr);

// sprawdza, czy dane zostały wczytane
if (bitmapImage == NULL)
{
fclose(filePtr);
return NULL;
}

// zamienia miejscami składowe R i B
for (imageIdx = 0; imageIdx < bitmapInfoHeader->biSizeImage; imageIdx+=3)
{
tempRGB = bitmapImage[imageIdx];
bitmapImage[imageIdx] = bitmapImage[imageIdx + 2];
bitmapImage[imageIdx + 2] = tempRGB;
}

// zamyka plik i zwraca wskaźnik bufora zawierającego wczytany obraz
fclose(filePtr);
return bitmapImage;
}

bool LadujTextury()
{
// ładuje obraz tekstury lądu
landTexture = UstawieniaBitmapy("green.bmp", &landInfo);
if (!landTexture)
return false;

// ładuje obraz tekstury wody
waterTexture = UstawieniaBitmapy("water.bmp", &waterInfo);
if (!waterTexture)
return false;

// tworzy mipmapy lądu
glGenTextures(1, &land);                 
glBindTexture(GL_TEXTURE_2D, land);       
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, landInfo.biWidth, landInfo.biHeight, GL_RGB, GL_UNSIGNED_BYTE, landTexture);

// tworzy mipmapy wody
glGenTextures(1, &water);
glBindTexture(GL_TEXTURE_2D, water);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, waterInfo.biWidth, waterInfo.biHeight, GL_RGB, GL_UNSIGNED_BYTE, waterTexture);

return true;
}

void RysujKwadrat(float xPos, float yPos, float zPos)
{

glPushMatrix();
glTranslatef(xPos, yPos, zPos);

glBindTexture(GL_TEXTURE_2D, land);
glBegin(GL_QUADS); // górna ściana

glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.5f, 1.5f, 1.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(1.5f, 1.5f, 1.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(1.5f, 1.5f, -1.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.5f, 1.5f, -1.5f);
glEnd();

glBegin(GL_QUADS); // przednia ściana
glTexCoord2f(0.0f, 0.0f); glVertex3f(1.5f, -1.5f, 1.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(1.5f, 1.5f, 1.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.5f, 1.5f, 1.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.5f, -1.5f, 1.5f);
glEnd();

glBegin(GL_QUADS); // prawa ściana
glTexCoord2f(0.0f, 0.0f); glVertex3f(1.5f, 1.5f, -1.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(1.5f, 1.5f, 1.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(1.5f, -1.5f, 1.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(1.5f, -1.5f, -1.5f);
glEnd();

glBegin(GL_QUADS); // lewa ściana
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.5f, -1.5f, 1.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.5f, 1.5f, 1.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.5f, 1.5f, -1.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.5f, -1.5f, -1.5f);
glEnd();

glBegin(GL_QUADS); // dolna ściana
glTexCoord2f(0.0f, 0.0f); glVertex3f(1.5f, -1.5f, 1.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.5f, -1.5f, 1.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.5f, -1.5f, -1.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(1.5f, -1.5f, -1.5f);
glEnd();

glBegin(GL_QUADS); // tylna ściana
glTexCoord2f(0.0f, 0.0f); glVertex3f(1.5f, 1.5f, -1.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(1.5f, -1.5f, -1.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.5f, -1.5f, -1.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.5f, 1.5f, -1.5f);
glEnd();

glPopMatrix();
}

void RysujTeren(float xPos, float yPos, float zPos)
{
glPushMatrix();
glTranslatef(xPos, yPos, zPos);
glBindTexture(GL_TEXTURE_2D, water);
glBegin(GL_QUADS); // górna ściana
glTexCoord2f(0.0f, 0.0f); glVertex3f(-100.5f, 10.5f, 100.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(100.5f, 10.5f, 100.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(100.5f, 10.5f, -100.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-100.5f, 10.5f, -100.5f);
glEnd();

glBegin(GL_QUADS); // przednia ściana
glTexCoord2f(0.0f, 0.0f); glVertex3f(10.5f, -10.5f, 10.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(10.5f, 10.5f, 10.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-10.5f, 10.5f, 10.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-10.5f, -10.5f, 10.5f);
glEnd();

glBegin(GL_QUADS); // prawa ściana
glTexCoord2f(0.0f, 0.0f); glVertex3f(10.5f, 10.5f, -10.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(10.5f, 10.5f, 10.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(10.5f, -10.5f, 10.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(10.5f, -10.5f, -10.5f);
glEnd();

glBegin(GL_QUADS); // lewa ściana
glTexCoord2f(0.0f, 0.0f); glVertex3f(-10.5f, -10.5f, 10.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-10.5f, 10.5f, 10.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-10.5f, 10.5f, -10.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-10.5f, -10.5f, -10.5f);
glEnd();

glBegin(GL_QUADS); // dolna ściana
glTexCoord2f(0.0f, 0.0f); glVertex3f(10.5f, -10.5f, 10.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-10.5f, -10.5f, 10.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-10.5f, -10.5f, -10.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(10.5f, -10.5f, -10.5f);
glEnd();

glBegin(GL_QUADS); // tylna ściana
glTexCoord2f(0.0f, 0.0f); glVertex3f(10.5f, 10.5f, -10.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(10.5f, -10.5f, -10.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-10.5f, -10.5f, -10.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-10.5f, 10.5f, -10.5f);
glEnd();

glPopMatrix();
}


void RysujScene()
{

glClearColor(0.0f,0.0f,0.0f,0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();

glPushMatrix();
glLoadIdentity();
glTranslatef(0.0f,0.0f,-30.0f);
glRotatef(angle, 0.0f,1.0f,0.0f);
RysujKwadrat(ruchbok,ruchgora,ruchprzod);
RysujTeren(0.0f,-20.0f,0.0f);
glPopMatrix();

glFlush();

SwapBuffers(g_HDC);
}

void InicjujScene()
{

glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // czarny kolor tła

glShadeModel(GL_SMOOTH); // cieniowanie gładkie
glEnable(GL_DEPTH_TEST); // włącza bufor głębi
glEnable(GL_CULL_FACE); // ukrywanie tylnych stron wielokątów
glFrontFace(GL_CCW); // czyli o porządku wierzchołków przeciwnym
glEnable(GL_TEXTURE_2D); // włącza tekstury dwuwymiarowe
 
LadujTextury();
}

void Oswietlenie()
{

glEnable(GL_LIGHTING); // włącza oświetlenie

// konfiguruje źródło światła GL_LIGHT0
glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight); // składowa otoczenia
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight); // składowa rozproszona
glLightfv(GL_LIGHT0, GL_POSITION, spotlightPosition); // położenie źródła światła

glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 40.0f);
glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 30.0f);
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, spotlightDirection);

// włącza źródło światła
glEnable(GL_LIGHT0);

glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);

glMaterialfv(GL_FRONT, GL_SPECULAR, matSpecular);
glMaterialf(GL_FRONT, GL_SHININESS, 10.0f);

}
void SetupPixelFormat(HDC hDC)
{

int nPixelFormat;

static PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW |
PFD_SUPPORT_OPENGL |
PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
32,
0, 0, 0, 0, 0, 0,
0,
0,
3,
0, 0, 0, 0,
16,
0,
0,
PFD_MAIN_PLANE,
0,
0, 0, 0,};

nPixelFormat = ChoosePixelFormat(hDC, &pfd);

SetPixelFormat(hDC, nPixelFormat, &pfd);

}
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

{

static HGLRC hRC;
static HDC hDC;
int width, height;

switch(message)
{
case WM_CREATE:

hDC = GetDC(hwnd);
g_HDC = hDC;
SetupPixelFormat(hDC);

hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);

return 0;
break;

case WM_KEYDOWN:
keyPressed[wParam] = true;
return 0;
break;

case WM_KEYUP:
keyPressed[wParam] = false;
return 0;
break;

case WM_CLOSE:
wglMakeCurrent(hDC, NULL);
wglDeleteContext(hRC);

PostQuitMessage(0);

return 0;
break;

case WM_SIZE:

height = HIWORD(lParam);
width = LOWORD(lParam);

if (height==0)
{
height=1;
}

glViewport(0, 0, width, height);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();

gluPerspective(54.0f, (GLfloat)width/(GLfloat)height,1.0f,1000.0f);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

return 0;
break;

default:
break;
}
return (DefWindowProc(hwnd, message, wParam, lParam));
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
HWND hwnd;
MSG msg;
bool done;

WNDCLASSEX windowClass;
windowClass.cbSize = sizeof(WNDCLASSEX);
windowClass.style = CS_HREDRAW | CS_VREDRAW;
windowClass.lpfnWndProc = WndProc;
windowClass.cbClsExtra = 0;
windowClass.cbWndExtra = 0;
windowClass.hInstance = hInstance;
windowClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
windowClass.hbrBackground = NULL;
windowClass.lpszMenuName = NULL;
windowClass.lpszClassName = "MojaKlasa";
windowClass.hIconSm = LoadIcon(NULL, IDI_WINLOGO);

if (!RegisterClassEx(&windowClass))
return 0;


hwnd = CreateWindowEx(NULL,
"MojaKlasa",
"Model Robota OpenGL",
WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_SYSMENU | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
100, 100,
400, 400,
NULL,
NULL,
hInstance,
NULL);


// sprawdza, czy utworzenie okna nie powiodło się (wtedy wartość hwnd równa NULL)
if (!hwnd)
return 0;



ShowWindow(hwnd, SW_SHOW);
UpdateWindow(hwnd);
InicjujScene();

done = false;

while (!done)
{
//////// sterowanie/////////////////
if (keyPressed['W'] || keyPressed ['w'])
{
ruchprzod = ruchprzod - 0.2;
}
if (keyPressed['S'] || keyPressed ['s'])
{
ruchprzod = ruchprzod + 0.2;
}
if (keyPressed['Q'] || keyPressed ['q'])
{
ruchgora = ruchgora + 0.2;
}
if (keyPressed['E'] || keyPressed ['e'])
{
ruchgora = ruchgora - 0.2;
}
if (keyPressed['A'] || keyPressed ['a'])
{
ruchbok = ruchbok - 0.2;
}
if (keyPressed['D'] || keyPressed ['d'])
{
ruchbok = ruchbok + 0.2;
}
if (keyPressed['L'] || keyPressed ['l'])
{
angle = angle + 1;
}
if (keyPressed['K'] || keyPressed ['k'])
{
angle = angle - 1;
}
//////////////koniec sterowania/////////////


PeekMessage(&msg, hwnd, NULL, NULL, PM_REMOVE);
if(msg.message == WM_QUIT)
{
done = true;

}
else
{
RysujScene();
Oswietlenie();


}


TranslateMessage(&msg);
DispatchMessage(&msg);


}
return msg.wParam;
}

I teraz pytanie zasadnicze: jak zaimplementować ten kod który wykrywa kolizje tak, aby działał. Być może są też inne sposoby na to.

Pozdrawiam: Pawel1503

Strony: 1 ... 31 32 33 34 [35]