Próby zakodzenia pierwszej gry :E

[lukaszt 0]

Jeśli chciałbys się przesiąść na C# to przy twoim aktualnym stanie wiedzy, to kwestia 2-3h nauki . Składnia jest prawie taka sama, jedynie nie masz biblioteki standardowej, a tą od .NETu. Moim zdaniem jest sporo lepsza. Tylko, że też mocno rozpieszcza programistę oferując dużo ułatwień. Dlatego nie wszyscy polecają języki takie jak JAVA czy C# na początek nauki.

[Zdziwiony 0]

Jeśli chciałbys się przesiąść na C# to przy twoim aktualnym stanie wiedzy, to kwestia 2-3h nauki . Składnia jest prawie taka sama, jedynie nie masz biblioteki standardowej, a tą od .NETu. Moim zdaniem jest sporo lepsza. Tylko, że też mocno rozpieszcza programistę oferując dużo ułatwień. Dlatego nie wszyscy polecają języki takie jak JAVA czy C# na początek nauki.

 

Myślisz, że naprawdę wiem na tyle dużo, żeby tak szybko to ogarnąć ?

 

Na razie chyba spróbuje przepisać swój program do tego Visuala , swoją drogą chyba zaraz założę nowy temat, bo tyle błędów ile mi tam wywala jest nie do ogarnięcia ... Cóż biorę się za naprawę...

 

EDIT: Dobra udało się, usunąłem obsługę wątków, i zainicjalizowałem zmienne: wszystko się ładnie kompiluje

Pierwszy + dla Visuala: Program zajmuje 200KB mniej niż w przypadku kompilatora GCC

 

EDIT2: Ale jest małe ale... Jak zrobić, żeby program uruchamiał się domyślnie z uprawnieniami administratora ? W C::B, wystarczyło w zasobach dopisać do nazwy Setup i było ok, a tu to nic nie daje

[fajny Rafałek 0]

No kolega trochę się zagalopował.

 

W C#, jak i w każdym innym języku tego typu jest masa niuansów, których na pewno się nie nauczysz w 2-3h, ale wyklepanie prostej aplikacji okienkowej w takim czasie nie powinno być problemem.

[lukaszt 0]

Chodziło mi o osiągnięcie poziomu mniej więcej jaki prezentujesz teraz Sama nauka C# (jak i każdego innego języka) powiedzmy żeby osiągnąc poziom "podstawowy" zajmuje "trochę" więcej niż te 2-3h

[Zdziwiony 0]

U mnie "trochę" = "trochę więcej"

 

Poza tym, murze się przyznać, że jeszcze nie skończyłem czytać kursu c++ (po pierwszych kilku lekcjach zacząłem coś sam kombinować, a na następne lekcje czasem wpadałem jak czegoś szukałem , to było pół roku temu i tak jest do teraz )

[Stanley 0]

Zobacz jak wczytuje bitmapę w moim programie, link wyżej, może gdzieś tu jest problem ?

 

podejrzewam że problem jest w kolejce mesedżów lub tworzeniu/podmianie DC(buforuje bitmapy i wszystkie elementy osobno) a nie w bitmapach

 

 

int suma; bez inicjalizacji zawartości a dalej

suma +=...

 

char SHGFP_TYPE_CURRENT; bez inicjalizacji zawartości a dalej

int SHGetFolderPathA(0, CSIDL_LOCAL_APPDATA, 0, SHGFP_TYPE_CURRENT

 

daj chociaż suma = 0; ..CURRENT = '\0'; a nie na oślep;

nie wiem jakim cudem GCC ci nie alarmowało

[Zdziwiony 0]

Jak w CURRENT w Visualu dam cokolwiek to program się sypie

dałem zamiast tej zmiennej NULL'a i działa, zresztą luknij w mój najnowszy temat , tam opisałem co dziwnego się dzieje z tym "programem"

 

EDIT: @Stanley zdążyłem przeczytać!

[Stanley 0]

a ić

głośno myśle, tym razem padło na Ciebie

 

przymiarka do gry w ponga(Dev++ 5.6.1, MinGW32-bit)

http://msdn.microsoft.com/en-us/library/windows/desktop/dd374211%28v=vs.85%29.aspx

 

/**************************
* Includes
*
**************************/

#include <windows.h>
#include <gl/gl.h>
#include <math.h>

/**************************
* Function Declarations
*
**************************/
class __glCurve {
public:
class __X {
protected:
	void *f_owner;
private: float f_x;
public:
	__stdcall  __X(void *a_owner){
	f_owner = a_owner;
	f_x = 0;
	};
	__stdcall ~__X(){
	};
void __stdcall operator= (float a_x) {
f_x = a_x;	
};
__stdcall operator float ()  {
return f_x;	
};
friend __glCurve;
} X;

	__stdcall  __glCurve(void) : X(this) {
	};
	__stdcall ~__glCurve(void){
	};

float __stdcall getX(__int32 param) {
return X;
};
float __stdcall getY(__int32 param) {
return 0;
};
float __stdcall getZ(__int32 param) {
return 0;
};
void __stdcall setX(float a_x, __int32 param) {
X = a_x;	
};
void __stdcall setY(float a_y, __int32 param) {

};
void __stdcall setZ(float a_z,__int32 param) {

};


};

class __glCircle : public __glCurve {
public:
};

class __glButton : public __glCurve {
public:
};





float circle (int k, int r, int h) {
 int x,y;
 glBegin(GL_TRIANGLE_FAN);
   for (int i = 0; i < 180; i++)
   {
   x = r * cos(i) - h;
   y = r * sin(i) + k;
   glVertex3f(x + k,y - h,0);

   x = r * cos(i + 0.1) - h;
   y = r * sin(i + 0.1) + k;
   glVertex3f(x + k,y - h,0);
   }
   glEnd();
}


LRESULT CALLBACK WndProc (HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam);
void EnableOpenGL (HWND hWnd, HDC *hDC, HGLRC *hRC);
void DisableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC);


/**************************
* WinMain
*
**************************/

int WINAPI WinMain (HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine,
                   int iCmdShow)
{

float x = 0, xi=0.05,y = 0, yi = 0.04,z = 0, zi=0.0;

   WNDCLASS wc;
   HWND hWnd;
   HDC hDC;
   HGLRC hRC;        
   MSG msg;
   BOOL bQuit = FALSE;
   float theta = 0.0f;

   /* register window class */
   wc.style = CS_OWNDC;
   wc.lpfnWndProc = WndProc;
   wc.cbClsExtra = 0;
   wc.cbWndExtra = 0;
   wc.hInstance = hInstance;
   wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
   wc.hCursor = LoadCursor (NULL, IDC_ARROW);
   wc.hbrBackground = (HBRUSH) GetStockObject (BLACK_BRUSH);
   wc.lpszMenuName = NULL;
   wc.lpszClassName = "GLSample";
   RegisterClass (&wc);

   /* create main window */
   hWnd = CreateWindow (
     "GLSample", "OpenGL Sample", 
     WS_CAPTION | WS_POPUPWINDOW | WS_VISIBLE,
     0, 0, 256, 256,
     NULL, NULL, hInstance, NULL);

   /* enable OpenGL for the window */
   EnableOpenGL (hWnd, &hDC, &hRC);

   /* program main loop */
   while (!bQuit)
   {
       /* check for messages */
       if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
       {
           /* handle or dispatch messages */
           if (msg.message == WM_QUIT)
           {
               bQuit = TRUE;
           }
           else
           {
               TranslateMessage (&msg);
               DispatchMessage (&msg);
           }
       }
       else
       {

glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//glEnable (GL_POLYGON_SMOOTH); 
//glShadeModel(GL_SMOOTH);
//glMatrixMode(GL_PROJECTION);
//glDisable(GL_DEPTH_TEST);
//glEnable(GL_BLEND);
//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glHint( GL_LINE_SMOOTH_HINT, GL_NICEST ); 
glHint( GL_POLYGON_SMOOTH_HINT, GL_NICEST ); 
glDisable( GL_LINE_SMOOTH ); 
glDisable( GL_POLYGON_SMOOTH );


__glCircle c; c.getX(0.0);



if (x>+1) xi=-0.05;
else
if (x<-1) xi=+0.05;

x+=xi; 

if (y>+1) yi=-0.04;
else
if (y<-1) yi=+0.04;

y+=yi; 
	glShadeModel(GL_SMOOTH);
       glEnable(GL_LIGHTING); // Render lit geometry. 
       glEnable(GL_LIGHT0);
       glShadeModel(GL_SMOOTH);

	glNormal3d(-1, -1, 1);
       GLfloat specular[] = { 1.0f, 1.0f, 1.0f , 1.0f};
       glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
       GLfloat ambient[]  = { 1.0f, 1.0f, 1.0f };
	glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
	GLfloat position[] = {-1.0f,+1.0f, +5.0f, 1.0f };
	glLightfv(GL_LIGHT0, GL_POSITION, position);

	glLightf (GL_LIGHT0, GL_SPOT_CUTOFF, 80.f);
	glLightf (GL_LIGHT0, GL_SPOT_EXPONENT,15);
	glEnable(GL_COLOR_MATERIAL);
	glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE);
	glMateriali(GL_FRONT, GL_SHININESS, 96);

	glBegin(GL_TRIANGLES);
        	glColor3f(0.5, 0.0, 0.0);
       glVertex3f(x + 0.0, y+ 0.0, 0.5);
        	glColor3f(0.0, 0.5, 0.0);
       glVertex3f(x + 0.2, y+ 0.0, 0.5);
        	glColor3f(0.0, 0.0, 0.5);
       glVertex3f(x + 0.1, y+ 0.2, 0.5);

       glEnd();
       glDisable(GL_LIGHTING); // Render non-lit geometry.

       SwapBuffers (hDC);
       Sleep (44);    
       }
   }

   /* shutdown OpenGL */
   DisableOpenGL (hWnd, hDC, hRC);

   /* destroy the window explicitly */
   DestroyWindow (hWnd);

   return msg.wParam;
}


/********************
* Window Procedure
*
********************/

LRESULT CALLBACK WndProc (HWND hWnd, UINT message,
                         WPARAM wParam, LPARAM lParam)
{

   switch (message)
   {
   case WM_CREATE:
       return 0;
   case WM_CLOSE:
       PostQuitMessage (0);
       return 0;

   case WM_DESTROY:
       return 0;

   case WM_KEYDOWN:
       switch (wParam)
       {
       case VK_ESCAPE:
           PostQuitMessage(0);
           return 0;
       }
       return 0;

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


/*******************
* Enable OpenGL
*
*******************/

void EnableOpenGL (HWND hWnd, HDC *hDC, HGLRC *hRC)
{
   PIXELFORMATDESCRIPTOR pfd;
   int iFormat;

   /* get the device context (DC) */
   *hDC = GetDC (hWnd);

   /* set the pixel format for the DC */
   ZeroMemory (&pfd, sizeof (pfd));
   pfd.nSize = sizeof (pfd);
   pfd.nVersion = 1;
   pfd.dwFlags = PFD_DRAW_TO_WINDOW | 
     PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
   pfd.iPixelType = PFD_TYPE_RGBA;
   pfd.cColorBits = 24;
   pfd.cDepthBits = 16;
   pfd.iLayerType = PFD_MAIN_PLANE;
   iFormat = ChoosePixelFormat (*hDC, &pfd);
   SetPixelFormat (*hDC, iFormat, &pfd);

   /* create and enable the render context (RC) */
   *hRC = wglCreateContext( *hDC );
   wglMakeCurrent( *hDC, *hRC );

}
/******************
* Disable OpenGL
******************/

void DisableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC)
{
   wglMakeCurrent (NULL, NULL);
   wglDeleteContext (hRC);
   ReleaseDC (hWnd, hDC);
}

 

od rysowania trójkąta do rysowania kuli z vertexów

http://people.sc.fsu.edu/~jburkardt/examples/meshlab/meshlab.html

ubrania w klasy, dodania tekstur,

żeby nie wymyślać koła od nowa

trzeba by poszukać gotowych bibliotek

http://www.opengl.org/resources/libraries/windowtoolkits/

 

API openGL jest wszędzie podobne(na linux, windows, mac), niezależnie od języka C, Basic, Objective-C,

webGL jeszcze bardziej niezależne

na desktopie można umieścić "GLView" w dowolnym oknie,

a śp. MFC, QT, VCL, fltk, wxWidgets, WinAPI, WinForms może być ramką bez wnikania, signal/slot i obiekty 2D - wystarczy hWnd i hDC

proste GetCursorPos do obsługi klikania obiektów załatwi wszystko

+ KeyboardHook do klawiatury

może to nawet lepiej że zaczynasz od WinAPI

bo jest upierdliwe i daje wyobrażenie że cała reszta to "nakładki" które ładnie ubierają upierdliwość w obiekty

 

trzymam kciuki za pierwszą, drugą i kolejne gry!

no i za prywatnego CCleanera

robić i robić i sie nie poddawać

 

Kurs OpenGL

http://cpp0x.pl/kursy/Kurs-OpenGL-C++/101

scene można umieścić w dowolnym obiekcie, oknie, panelu, przycisku

 

HWND OpenGL_hWnd;
HDC OpenGL_hDC;
HGLRC OpenGL_hRC;        

OpenGL_hWnd =CreateWindowExW(NULL,
           L"BUTTON",
           _T("*"),
           WS_VISIBLE|
           WS_CHILD|BS_PUSHBUTTON,
           10,
           10,
           200,
           300,
           hWnd,
           (HMENU)NULL,
           hInstance,
           NULL);
SetWindowPos(OpenGL_hWnd,hWnd,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
EnableOpenGL(OpenGL_hWnd, &OpenGL_hDC, &OpenGL_hRC);

 

w VCL OpenGL_hWnd = Form1->Handle; hDC = Form1->Canvas->Handle;

w QT ->

 

HWND getHWNDForWidget(const QWidget* widget)
{
   QWindow* window = ::windowForWidget(widget);
   if (window && window->handle())
   {
       QPlatformNativeInterface* interface = QGuiApplication::platformNativeInterface();
       return static_cast<HWND>(interface->nativeResourceForWindow(QByteArrayLiteral("handle"), window));
   }
   return 0; 
}
HDC OpenGL_hDC = this->getDC();
this->releseDC();

 

 

GLUT w akcji:

2D

https://www.cs.umd.edu/class/spring2013/cmsc425/OpenGL/OpenGLSamples/OpenGL-2D-Sample/opengl-2D-sample.cpp

3D

http://graphics.stanford.edu/courses/cs248-00/helpsession/opengl/code_example.html

 

proste jak budowa cepa, chwila moment i można by quejka zrobić

 

a później G3D

http://sourceforge.net/projects/g3d/?source=directory

(na licencji MIT)

[Zdziwiony 0]

Spoko, ja tam nic do Ciebie nie mam W sumie dobrze, że to napisałeś - zapamiętam

Uwierz mi gorsze rzeczy piszą na forum cpp0x.pl jak czegoś nie wiesz

[Stanley 0]

zostawiam linka do kodu + exe(uaktualnianego co jakiś czas)

https://dl.dropboxusercontent.com/u/10755180/PC/PierwszaGraWOpenGL/OpenGL_example.zip

scena 3D renderuje sie w CreateWindowEx("STATIC",...) i lata kwadrat

 

EDIT: po przeczytaniu tutoriali i zapoznaniu również z GLSL - DirectX jest jednak lepsze...openGL to masakra bez dodatkowych bibliotek ani rusz