Autor Wątek: Dab -- język programowania na potrzeby gier  (Przeczytany 25732 razy)

Offline nembutal

  • Użytkownik

# Wrzesień 07, 2011, 13:26:47
Czy jest jakakolwiek specyfikacja?
BTW od paru lat już z powodzeniem nie używam plików nagłówkowych w C++ :)

Offline Mr. Spam

  • Miłośnik przetworów mięsnych

Offline Dab

  • Redaktor
    • blog

# Wrzesień 07, 2011, 13:33:37
Specyfikacja i ogólnie dokumentacja założeń/składni itd. się powoli tworzy.

Offline hashedone

  • Użytkownik

# Wrzesień 07, 2011, 15:11:41
Ale ty chyba Dab nie zrozumiałeś. Same programy się odpalają i działają, pod warunkiem użycia "Run internally". Próba użycia "Run" oraz "Fix definitions" powoduje "Program Dab.exe przestać działać". Żadne testlog.txt się nie generuje.

Offline FoToN

  • Użytkownik

# Wrzesień 07, 2011, 16:41:26
To prawie na pewno nie brak funkcji bo driver to obsługuje i w dodatku gra się włącza. Crash jest dopiero przy oddaniu strzału (a dokładniej gdy dotknie tego rombu lub krańca ekranu).

Log:
Will JIT

Will compile 40971 bytes of code...



* loaded function `_f_file_open_pu1pi4`

* loaded function `_f_file_close_pu1`

* loaded function `_f_GameInit_`

* loaded function `_f_ll_S5vec3tS5vec3t`

* loaded function `_f_GameUpdate_f`

* loaded function `_f_CameraCam_`

* loaded function `_f_ResetCamera_`

* loaded function `_f_GameRender_`

* loaded function `_f_GameParticlesUpdate_f`

* loaded function `_f_memzero_pu1u4`

* loaded function `_f_ExitWithError_s`

* loaded function `_f_CenterWindow_u4`

* loaded function `_f_myglcreatecontext_`

* loaded function `_f_ProcessMessage_u4u4u4`

* loaded function `_f_xgame_pumpmsg_u4`

* loaded function `_f_xgame_main_`

* loaded function `_f_main_`

* loaded function `_f_ModelLoad_s`

* loaded function `_f_ModelDraw_pS9GameModel`

* loaded function `_f_smoothstep_f`

* loaded function `_f_ssrange_ff`

* loaded function `_f_make_pos_ff`

* loaded function `_f_RenderModelX_pS9GameModelS3posff`

* loaded function `_f_vec3_fff`

* loaded function `_f_InitParticleBuffer_`

* loaded function `_f_AddParticle_S5vec3tS5vec3tS5vec3tS5vec3tfff`

* loaded function `_f_AddParticle_S5vec3tS5vec3tS5vec3tS5vec3tff`

* loaded function `_f_DeleteParticle_i4`

* loaded function `_f_ParticleInit_`

* loaded function `_f_mul_fS5vec3t`

* loaded function `_f_add_S5vec3tS5vec3t`

* loaded function `_f_sub_S5vec3tS5vec3t`

* loaded function `_f_frand_`

* loaded function `_f_ParticlesUpdate_f`

* loaded function `_f_add_part_memb_i4i4f`

* loaded function `_f_ParticlesRender_`

* loaded function `_f_renderDigit_i4bbbbbbb`

* loaded function `_f_renderDigit_i4i4`

* loaded function `_f_renderNumber_i4`

* loaded function `_f_LoadShaderProgram_pu1i4`

* loaded function `_f_ShaderLoad_s`

* loaded function `_f_ShaderUse_pS10GameShader`

* loaded function `_f_image_load_pu1i4pi4pi4`

* loaded function `_f_image_free_pu1`

* loaded function `_f_LoadTexture_s`

* loaded function `_f_LoadTextureF_pu1`

* loaded function `_f_zzSetupTime_`

* loaded function `_f_zzSetTime_pi8`

* loaded function `_f_zzUpdateTime_`

* loaded function `_f_glCheck_`

* loaded function `_f_glCheck2_s`

* loaded function `_f_glGetString_i4`

* loaded function `_f_glGetError_`

* loaded function `_f_glPushMatrix_`

* loaded function `_f_glPopMatrix_`

* loaded function `_f_glBlendFunc_u4u4`

* loaded function `_f_glEnable_i4`

* loaded function `_f_glDisable_i4`

* loaded function `_f_glClear_i4`

* loaded function `_f_glDepthMask_u4`

* loaded function `_f_glClearColor_ffff`

* loaded function `_f_glLoadIdentity_`

* loaded function `_f_glColor3f_fff`

* loaded function `_f_glLineWidth_f`

* loaded function `_f_glFlush_`

* loaded function `_f_glRecti_i4i4i4i4`

* loaded function `_f_glRectf_ffff`

* loaded function `_f_glViewport_i4i4i4i4`

* loaded function `_f_glMatrixMode_i4`

* loaded function `_f_glOrtho_llllll`

* loaded function `_f_glDrawElements_u4u4u4pu1`

* loaded function `_f_glGetFloatv_u4pf`

* loaded function `_f_glGenTextures_u4pu4`

* loaded function `_f_glBindTexture_u4u4`

* loaded function `_f_glTexImage2D_u4u4u4u4u4u4u4u4pu1`

* loaded function `_f_glTexParameteri_u4u4u4`

* loaded function `_f_glTranslatef_fff`

* loaded function `_f_glRotatef_ffff`

* loaded function `_f_glDrawArrays_u4u4u4`

* loaded function `_f_gluLookAt_lllllllll`

* loaded function `_f_gluPerspective_llll`

* loaded function `_f_glGenBuffers_i4pu4`

* loaded function `_f_glBindBuffer_i4u4`

* loaded function `_f_glBufferData_i4u4pCu1i4`

* loaded function `_f_glBindVertexArray_u4`

* loaded function `_f_glGenVertexArrays_u4pu4`

* loaded function `_f_glDisableVertexAttribArray_u4`

* loaded function `_f_glEnableVertexAttribArray_u4`

* loaded function `_f_glVertexAttribPointer_u4u4u4u4u4u4`

* loaded function `_f_glCreateShader_u4`

* loaded function `_f_glShaderSource_u4u4ppu1pu4`

* loaded function `_f_glCompileShader_u4`

* loaded function `_f_glGetShaderiv_u4u4pu4`

* loaded function `_f_glGetProgramiv_u4u4pu4`

* loaded function `_f_glGetShaderInfoLog_u4u4pu4pu1`

* loaded function `_f_glGetProgramInfoLog_u4u4pu4pu1`

* loaded function `_f_glDeleteShader_u4`

* loaded function `_f_glCreateProgram_`

* loaded function `_f_glAttachShader_u4u4`

* loaded function `_f_glLinkProgram_u4`

* loaded function `_f_glUseProgram_u4`

* loaded function `_f_glGetUniformLocation_u4s`

* loaded function `_f_glUniformMatrix4fv_u4u4u4pf`

* loaded function `_f_glUniform1i_u4i4`

* loaded function `_f_glBufferSubData_u4u4u4pu1`

* loaded function `_f_printf_sv`

* loaded function `_f_sprintf_pu1sv`

* loaded function `_f_fopen_pu1pu1`

* loaded function `_f_fclose_pS4FILE`

* loaded function `_f_fread_pu1u4u4pS4FILE`

* loaded function `_f_ftell_pS4FILE`

* loaded function `_f_fseek_pS4FILEi4i4`

* loaded function `_f_strlen_pu1`

* loaded function `_f_malloc_u4`

* loaded function `_f_free_pu1`

* loaded function `_f_rand_`

* loaded function `_f_load_gl_func_`

* loaded function `_f_breakx_`

* loaded function `_f_MessageBox_i4ssi4`

* loaded function `_f_GetModuleHandle_i4`

* loaded function `_f_LoadIcon_u4i4`

* loaded function `_f_LoadCursor_u4i4`

* loaded function `_f_RegisterClass_pS8WNDCLASS`

* loaded function `_f_AdjustWindowRectEx_pS4RECTu4u4u4`

* loaded function `_f_CreateWindowEx_u4ssu4i4i4i4i4u4u4u4pu1`

* loaded function `_f_ShowWindow_u4i4`

* loaded function `_f_SetForegroundWindow_u4`

* loaded function `_f_SetFocus_u4`

* loaded function `_f_GetDC_u4`

* loaded function `_f_ChoosePixelFormat_u4pS21PIXELFORMATDESCRIPTOR`

* loaded function `_f_SetPixelFormat_u4i4pS21PIXELFORMATDESCRIPTOR`

* loaded function `_f_wglCreateContext_u4`

* loaded function `_f_wglMakeCurrent_u4u4`

* loaded function `_f_SwapBuffers_u4`

* loaded function `_f_PeekMessage_pS3MSGu4u4u4u4`

* loaded function `_f_TranslateMessage_pS3MSG`

* loaded function `_f_DispatchMessage_pS3MSG`

* loaded function `_f_GetWindowRect_u4pS4RECT`

* loaded function `_f_GetSystemMetrics_i4`

* loaded function `_f_MoveWindow_u4i4i4i4i4u4`

* loaded function `_f_QueryPerformanceCounter_pi8`

* loaded function `_f_QueryPerformanceFrequency_pi8`

* loaded function `_f_ExitProcess_u4`

will run...



#1

Prebuilding fun `file_open`

Prebuilding fun `file_close`

Prebuilding fun `GameInit`

Prebuilding fun `ll`

Prebuilding fun `GameUpdate`

Prebuilding fun `CameraCam`

Prebuilding fun `ResetCamera`

Prebuilding fun `GameRender`

Prebuilding fun `GameParticlesUpdate`

Prebuilding fun `memzero`

Prebuilding fun `ExitWithError`

Prebuilding fun `CenterWindow`

Prebuilding fun `myglcreatecontext`

Prebuilding fun `ProcessMessage`

Prebuilding fun `xgame_pumpmsg`

Prebuilding fun `xgame_main`

Prebuilding fun `main`

Prebuilding fun `ModelLoad`

Prebuilding fun `ModelDraw`

Prebuilding fun `smoothstep`

Prebuilding fun `ssrange`

Prebuilding fun `make_pos`

Prebuilding fun `RenderModelX`

Prebuilding fun `vec3`

Prebuilding fun `InitParticleBuffer`

Prebuilding fun `AddParticle`

Prebuilding fun `AddParticle`

Prebuilding fun `DeleteParticle`

Prebuilding fun `ParticleInit`

Prebuilding fun `mul`

Prebuilding fun `add`

Prebuilding fun `sub`

Prebuilding fun `frand`

Prebuilding fun `ParticlesUpdate`

Prebuilding fun `add_part_memb`

Prebuilding fun `ParticlesRender`

Prebuilding fun `renderDigit`

Prebuilding fun `renderDigit`

Prebuilding fun `renderNumber`

Prebuilding fun `LoadShaderProgram`

Prebuilding fun `ShaderLoad`

Prebuilding fun `ShaderUse`

LOAD EXTERN 732c0000 732c1000 <stb_loader.dll -> image_load>

LOAD EXTERN 732c0000 732c1030 <stb_loader.dll -> image_free>

Prebuilding fun `LoadTexture`

Prebuilding fun `LoadTextureF`

Prebuilding fun `zzSetupTime`

Prebuilding fun `zzSetTime`

Prebuilding fun `zzUpdateTime`

Prebuilding fun `glCheck`

Prebuilding fun `glCheck2`

LOAD EXTERN 72d40000 72d43ced <opengl32.dll -> glGetString>

LOAD EXTERN 72d40000 72d43a23 <opengl32.dll -> glGetError>

LOAD EXTERN 72d40000 72d41ed4 <opengl32.dll -> glPushMatrix>

LOAD EXTERN 72d40000 72d41ec8 <opengl32.dll -> glPopMatrix>

LOAD EXTERN 72d40000 72d436c0 <opengl32.dll -> glBlendFunc>

LOAD EXTERN 72d40000 72d41de4 <opengl32.dll -> glEnable>

LOAD EXTERN 72d40000 72d41dd8 <opengl32.dll -> glDisable>

LOAD EXTERN 72d40000 72d42030 <opengl32.dll -> glClear>

LOAD EXTERN 72d40000 72d433c3 <opengl32.dll -> glDepthMask>

LOAD EXTERN 72d40000 72d420c9 <opengl32.dll -> glClearColor>

LOAD EXTERN 72d40000 72d41e80 <opengl32.dll -> glLoadIdentity>

LOAD EXTERN 72d40000 72d418bc <opengl32.dll -> glColor3f>

LOAD EXTERN 72d40000 72d42d63 <opengl32.dll -> glLineWidth>

LOAD EXTERN 72d40000 72d4345c <opengl32.dll -> glFlush>

LOAD EXTERN 72d40000 72d4235a <opengl32.dll -> glRecti>

LOAD EXTERN 72d40000 72d422f4 <opengl32.dll -> glRectf>

LOAD EXTERN 72d40000 72d44020 <opengl32.dll -> glViewport>

LOAD EXTERN 72d40000 72d41ea4 <opengl32.dll -> glMatrixMode>

LOAD EXTERN 72d40000 72d43fed <opengl32.dll -> glOrtho>

LOAD EXTERN 72d40000 72d41f64 <opengl32.dll -> glDrawElements>

LOAD EXTERN 72d40000 72d43a56 <opengl32.dll -> glGetFloatv>

LOAD EXTERN 72d40000 72d44185 <opengl32.dll -> glGenTextures>

LOAD EXTERN 72d40000 72d41f34 <opengl32.dll -> glBindTexture>

LOAD EXTERN 72d40000 72d421c2 <opengl32.dll -> glTexImage2D>

LOAD EXTERN 72d40000 72d42f2e <opengl32.dll -> glTexParameteri>

LOAD EXTERN 72d40000 72d41f1c <opengl32.dll -> glTranslatef>

LOAD EXTERN 72d40000 72d41eec <opengl32.dll -> glRotatef>

LOAD EXTERN 72d40000 72d41f58 <opengl32.dll -> glDrawArrays>

LOAD EXTERN 72d10000 72d1a6f6 <glu32.dll -> gluLookAt>

LOAD EXTERN 72d10000 72d1a5cb <glu32.dll -> gluPerspective>

LOAD EXTERN 7c340000 7c369cbd <MSVCR71.DLL -> fopen>

LOAD EXTERN 7c340000 7c350223 <MSVCR71.DLL -> fclose>

LOAD EXTERN 7c340000 7c36ba07 <MSVCR71.DLL -> fread>

LOAD EXTERN 7c340000 7c36bd55 <MSVCR71.DLL -> ftell>

LOAD EXTERN 7c340000 7c36bb92 <MSVCR71.DLL -> fseek>

LOAD EXTERN 7c340000 7c3417d5 <MSVCR71.DLL -> strlen>

LOAD EXTERN 7c340000 7c3416e9 <MSVCR71.DLL -> malloc>

LOAD EXTERN 7c340000 7c342151 <MSVCR71.DLL -> free>

LOAD EXTERN 7c340000 7c366be9 <MSVCR71.DLL -> rand>

LOAD EXTERN 76470000 764cea11 <user32.dll -> MessageBoxA>

LOAD EXTERN 76a90000 76add8f3 <kernel32.dll -> GetModuleHandleA>

LOAD EXTERN 76470000 764764ad <user32.dll -> LoadIconA>

LOAD EXTERN 76470000 76478328 <user32.dll -> LoadCursorA>

LOAD EXTERN 76470000 7647bc6a <user32.dll -> RegisterClassA>

LOAD EXTERN 76470000 764848ba <user32.dll -> AdjustWindowRectEx>

LOAD EXTERN 76470000 7647bf40 <user32.dll -> CreateWindowExA>

LOAD EXTERN 76470000 7647f2a9 <user32.dll -> ShowWindow>

LOAD EXTERN 76470000 7647b225 <user32.dll -> SetForegroundWindow>

LOAD EXTERN 76470000 7647abad <user32.dll -> SetFocus>

LOAD EXTERN 76470000 7648544c <user32.dll -> GetDC>

LOAD EXTERN 75060000 750967dd <gdi32.dll -> ChoosePixelFormat>

LOAD EXTERN 75060000 7509689c <gdi32.dll -> SetPixelFormat>

LOAD EXTERN 72d40000 72d7b8e0 <opengl32.dll -> wglCreateContext>

LOAD EXTERN 72d40000 72d7955b <opengl32.dll -> wglMakeCurrent>

LOAD EXTERN 75060000 7509694b <gdi32.dll -> SwapBuffers>

LOAD EXTERN 76470000 764819a5 <user32.dll -> PeekMessageA>

LOAD EXTERN 76470000 764864c7 <user32.dll -> TranslateMessage>

LOAD EXTERN 76470000 76482e32 <user32.dll -> DispatchMessageA>

LOAD EXTERN 76470000 7648558c <user32.dll -> GetWindowRect>

LOAD EXTERN 76470000 764867cf <user32.dll -> GetSystemMetrics>

LOAD EXTERN 76470000 76478d29 <user32.dll -> MoveWindow>

LOAD EXTERN 76a90000 76adc422 <Kernel32.dll -> QueryPerformanceCounter>

LOAD EXTERN 76a90000 76ad2b1a <Kernel32.dll -> QueryPerformanceFrequency>

LOAD EXTERN 76a90000 76aebbe2 <kernel32.dll -> ExitProcess>

#2

podam empty wnd proc: '0028f050'

#3

#44

fun: 01AD5EB0

llvm: 035163E8

#55

Running...



OpenGL Version [3.3.9836 Compatibility Profile Context]

LOAD OPENGL 72d40000 72d7c245 69e20480 <glAttachShader>

LOAD OPENGL 72d40000 72d7c245 69e20080 <glBindBuffer>

LOAD OPENGL 72d40000 72d7c245 69e22b40 <glBindVertexArray>

LOAD OPENGL 72d40000 72d7c245 69e20180 <glBufferData>

LOAD OPENGL 72d40000 72d7c245 69e201c0 <glBufferSubData>

LOAD OPENGL 72d40000 72d7c245 69e203c0 <glCompileShader>

LOAD OPENGL 72d40000 72d7c245 69e20440 <glCreateProgram>

LOAD OPENGL 72d40000 72d7c245 69e20340 <glCreateShader>

LOAD OPENGL 72d40000 72d7c245 69e20400 <glDeleteShader>

LOAD OPENGL 72d40000 72d7c245 69e21800 <glDisableVertexAttribArray>

LOAD OPENGL 72d40000 72d7c245 69e217c0 <glEnableVertexAttribArray>

LOAD OPENGL 72d40000 72d7c245 69e20100 <glGenBuffers>

LOAD OPENGL 72d40000 72d7c245 69e22ac0 <glGenVertexArrays>

LOAD OPENGL 72d40000 72d7c245 69e20cc0 <glGetProgramInfoLog>

LOAD OPENGL 72d40000 72d7c245 69e20c00 <glGetProgramiv>

LOAD OPENGL 72d40000 72d7c245 69e20c80 <glGetShaderInfoLog>

LOAD OPENGL 72d40000 72d7c245 69e20b80 <glGetShaderiv>

LOAD OPENGL 72d40000 72d7c245 69e205c0 <glGetUniformLocation>

LOAD OPENGL 72d40000 72d7c245 69e20500 <glLinkProgram>

LOAD OPENGL 72d40000 72d7c245 69e20380 <glShaderSource>

LOAD OPENGL 72d40000 72d7c245 69e20740 <glUniform1i>

LOAD OPENGL 72d40000 72d7c245 69e20ac0 <glUniformMatrix4fv>

LOAD OPENGL 72d40000 72d7c245 69e20540 <glUseProgram>

LOAD OPENGL 72d40000 72d7c245 69e21780 <glVertexAttribPointer>

file `data\frigate.utm`: read 46875 of 46875 bytes

Vertex count: 894

file `data\frigateD.jpg`: read 181193 of 181193 bytes

Texture `data\frigateD.jpg` -> 512x512

file `data\enemy.utm`: read 1635 of 1635 bytes

Vertex count: 24

file `data\enemyD.jpg`: read 18508 of 18508 bytes

Texture `data\enemyD.jpg` -> 512x512

file `data\grid.utm`: read 699 of 699 bytes

Vertex count: 6

file `data\gridD.jpg`: read 4937 of 4937 bytes

Texture `data\gridD.jpg` -> 256x256

file `data\render_ps.txt`: read 511 of 511 bytes

Shader compile log:

Fragment shader was successfully compiled to run on hardware.

file `data\render_vs.txt`: read 387 of 387 bytes

Shader compile log:

Vertex shader was successfully compiled to run on hardware.



Program link log:

Fragment shader(s) linked, vertex shader(s) linked.

file `data\particle_ps.txt`: read 292 of 292 bytes

Shader compile log:

Fragment shader was successfully compiled to run on hardware.

file `data\particle_vs.txt`: read 698 of 698 bytes

Shader compile log:

Vertex shader was successfully compiled to run on hardware.



Program link log:

Fragment shader(s) linked, vertex shader(s) linked.

file `data\particle.png`: read 11354 of 11354 bytes

Texture `data\particle.png` -> 256x256

OpenGL error 1281

OpenGL error 1281





ERROR: ACCESS VIOLATION!







 *** Return value: 0

Did JIT

Offline ANtY

  • With fury and fire
  • Użytkownik
    • ANtY

  • Zbanowany
# Wrzesień 07, 2011, 20:53:11
Dobra uwaga, jestem noobem jeśli chodzi o kodzenie, używałem tylko pascala i cpp, czemu miałbym się na to przesiąść z c++a? Możesz później wyjaśnienie wrzucić na swoją stronkę, bo na pewno się przyda.

Coś oprócz zmiany z release na debug podczas działania programu?

Rozumiem, że nie ma żadnej przewagi nad c++? Po co w takim razie czas tracić?

Offline DamianDev

  • Użytkownik

# Wrzesień 07, 2011, 21:16:04
Powiem tak zobaczylem zrodla gry ;) i powiem ze kod mi sie podoba ;) naprawde fajnie to wyglada.
« Ostatnia zmiana: Wrzesień 07, 2011, 21:18:48 wysłana przez DamianDev »

Offline arturooo3

  • Użytkownik

# Wrzesień 07, 2011, 22:38:03
http://arturooo.webd.pl/myupload/dab.jpg
Taki oto obraz ukazał mi się po uruchomieniu "internally" jak i normalnym - tym razem program się nie zawiesił (Win7x64), ale niestety dużo nie ukazał..
Wg. glGetString(GL_VERSION) 3.2.9262

Można wiedzieć, jak?
olo16, zapewne całość mamy w main.cpp i się wielce cieszymy ;).

Ja przejrzałem kod (pobieżnie) i w sumie nie czuję się przekonany do zastąpienia (jeszcze) zwykłego C++ z sensownie napisanym silnikiem.

Natomiast brakuje wielu drobnostek w IDE - np. "Jump to definition" etc.
« Ostatnia zmiana: Wrzesień 07, 2011, 22:42:52 wysłana przez arturooo3 »

Offline Kos

  • Użytkownik
    • kos.gd

# Wrzesień 07, 2011, 23:14:12
Dab, trzeci raz pytam... Planujesz rozszerzyć jakoś funkcję C w kierunku dynamiczności? W pierwszej kolejności chodzi mi tu o delegaty (omg koniecznie!), w drugiej zaś - o funkcje lokalne i domknięcia. Jedno i drugie przydaje się w stylu zorientowanym na zdarzenia, a to jest generalnie bardzo fajny styl.

Offline Dab

  • Redaktor
    • blog

# Wrzesień 07, 2011, 23:19:37
Cytuj
Natomiast brakuje wielu drobnostek w IDE - np. "Jump to definition" etc.

Pewnie, masy rzeczy brakuje. Ale z drugiej strony podejrzewam, że Visual ma trochę więcej niż 800 linii które zajmuje IDE Daba ;)

Cytuj
Planujesz rozszerzyć jakoś funkcję C w kierunku dynamiczności? W pierwszej kolejności chodzi mi tu o delegaty (omg koniecznie!), w drugiej zaś - o funkcje lokalne i domknięcia.

W rdzeniu języka nie. W module skryptowym (prototype-based) prawdopodobnie tak.

Offline Kos

  • Użytkownik
    • kos.gd

# Wrzesień 07, 2011, 23:22:36
Cytuj
W rdzeniu języka nie.

http://bit.ly/7C6b2K

Offline Frondeus

  • Użytkownik

# Wrzesień 08, 2011, 20:27:27
Popieram Kosa. Jakbym miał robić język (a moze robie ;] ?) to jednym z feature-keyów były by delegaty!
 

Offline Dab

  • Redaktor
    • blog

# Wrzesień 08, 2011, 20:41:44
Nie bardzo widzę gdzie chcecie wpakować delegaty do języka który nie jest obiektowy. :)

Ważniejsze dla mnie są np. adnotacje na temat parametrów wejściowych/wyjściowych czy zautomatyzowane testy. Coś w stylu:

[arg target in (GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, GL_PIXEL_UNPACK_BUFFER)]
[arg access in (GL_READ_ONLY, GL_WRITE_ONLY, GL_READ_WRITE)]
[out glGetError() == GL_NO_ERROR]
void * glMapBuffer(GLenum  target,  GLenum  access);
« Ostatnia zmiana: Wrzesień 08, 2011, 20:52:42 wysłana przez Dab »

Offline Frondeus

  • Użytkownik

# Wrzesień 08, 2011, 21:15:01
Mówiłeś że OOP z głową czy coś ;) A jak z głową to i z delegatami :)

Offline Kos

  • Użytkownik
    • kos.gd

# Wrzesień 08, 2011, 21:21:03
Miałem na myśli delegaty szeroko pojęte - ogólnie jakoś zaimplementowane krotki (wskaźnik na funkcję, dowolny zestaw parametrów), by można było robić (z jakąkolwiek składnią) np.:

void myFunction(int, int, int);
struct X {
    void function(void) * someCallback;
} x;
x.someCallback = myFunction@(10, 15, 20);

Albo nawet (jak już się chcemy starać, a lambdy są brzydkie):void function(int) * someCallback = myFunction@(10, ? 20);
someCallback(15); // calls myFunction(10, 15, 20)

Takie coś wbudowane w język (podobnie jak funkcje lokalne i domknięcia - pokrewny temat) robi czary przy programowaniu opartym o eventy, a fajnie się składa, że w ten sposób się b.fajnie pisze gry.

Cytuj
Ważniejsze dla mnie są np. adnotacje na temat parametrów wejściowych/wyjściowych czy zautomatyzowane testy.
To nie rób tego jako "adnotacje na temat parametrów", tylko potraktuj porządnie i nazwij "preconditions" i
"postconditions", by można było w ten sam sposób ustalić nie tylko zakres wartości dla konkretnych parametrów, ale i dowolne zależności między nimi (słowem - wszystko, co normalnie się upycha w asserty na początku funkcji). Ja bym proponował składnię w stylu:

void replace(StringBuffer b, int start, int end, String repl)
    pre {
        start <= end,
        end < b.getLength()
    }
    post {

    };

nadal w sygnaturze funkcji, ale po nazwie metody i parametrach, by dało się to czytać/.

BTW, ten sam pomysł był w D (preconditions, postconditions i dodatkowo inwarianty dla klas sprawdzane bodaj po każdej metodzie publicznej), inspirowałeś się?



Also, co konkretnie zyskujemy przez zautomatyzowane testy wbudowane w język? Nie twierdzę, że nic, ale wszędzie poza D  widziałem biblioteki do testów jako, duh, biblioteki, i działało zacnie.

Offline rm-f

  • Użytkownik
    • Tu trolluje

# Wrzesień 08, 2011, 21:23:59
Kos, jak mamy nazywać coś po imieniu to nazwijmy to programowaniem kontraktowym, a nie jakieś anglicyzmy.