Als je deze pagina ziet ben je hier waarschijnlijk gekomen via mijn onderschrift op de Nederlandse Game Maker Community. Zoals al een tijdje in mijn onderschrift staat ben ik bezig met een nieuwe versie van Model Creator, namelijk v6. Deze versie is echter gemaakt in C++, en daarom kan ik ook geen topic ervoor maken bij Work In Progress (eens het programma bruikbaar genoeg is maak ik wel een topic bij tutorials, als tool). In plaats daarvan heb ik dus deze pagina gemaakt. Reacties zijn altijd welkom per PM.
19 augustus 2011
Ik heb als experiment eens getest of ik mijn MCSL demo ook kon compileren voor Ubuntu. Ik heb wel wat correcties moeten doen om het te laten werken (GCC is strenger dan VC++ blijkbaar), maar het viel uiteindelijk heel goed mee, dankzij wxWidgets. Ik weet niet echt waarom, maar de Ubuntu-versie is zelfs een klein beetje sneller dan de Windows-versie, dus dat is ook mooi meegenomen. Als het me ook lukt om OpenGL te laten werken in Ubuntu, zal het niet moeilijk zijn om dat ook te doen voor MCv6.
Voor wie het wil testen:
MCSL Demo voor Windows
MCSL Demo voor Ubuntu (gemaakt in 11.04, geen idee of het ook werkt voor andere versies)
5 augustus 2011
Ik weet het, ik heb al lange tijd niets nieuws meer gepost, maar in heb MCv6 niet opgegeven :). Ik ben overgestapt naar wxWidgets 2.9.2 (zodat ik geen tijd meer verlies met het maken van een eigen engine), en ik ben nu ook OpenGL gaan gebruiken in plaats van DirectX (OpenGL gaat beter samen met wxWidgets). Hierdoor is de code nu (in theorie) cross-platform, wat misschien nog wel van pas kan komen aangezien er ook een Game Maker voor Mac bestaat (hoewel die voorlopig blijkbaar nog niet erg populair is). Natuurlijk betekent de overstap naar wxWidgets en OpenGL dat ik een groot deel van wat ik al had moet herschrijven, dus dat zorgt wel voor veel extra werk. Maar ik denk dat het op lange termijn het wel waard is, want hiermee bespaar ik veel tijd in de toekomst (wxWidgets heeft allerlei functies die heel handig zijn voor wat ik wil doen, bijvoorbeeld het laden van PNG, GIF en JPEG. Dat is iets wat mijn eigen engine nog niet kon).
MCSL is nu praktisch af. Hier is een nieuwe demo voor wie het wilt testen: link. In het zipbestand zitten ook wat testscripts als voorbeeldcode. Er zijn nu arrays (1D en 2D), en ik heb er een hoop bugs uit gehaald (waarschijnlijk nog niet allemaal, maar het is toch al een tijdje geleden dat ik een fout zag). Ik heb ook een topic gemaakt voor deze demo op cppforum.nl, dus als je een bug hebt gevonden of commentaar wilt geven kan dat nu ook daar.
Nu het vakantie is (en ik weer thuis ben) heb ik heel veel tijd, dus verwacht dat MCv6 nu wel wat sneller zal vorderen. Mijn doel is om voor het einde van mijn vakantie (half september) een versie te kunnen uploaden die de belangrijkste functies heeft (opslaan, laden, selecteren, verplaatsen, tekenen, transformaties, ...).
25 april 2011
Ik ben nu al een tijdje aan het werken aan een scripttaal voor MCv6. Ik dacht dat een scripttaal wel handig zou zijn, want het gebeurt vaak dat iets wat voor een computer heel simpel is voor een mens heel veel werk is. Met de scripttaal zou je bepaalde aanpassingen aan je model kunnen doen die lang zouden duren als je ze handmatig moet doen - een beetje zoals de 'expressions' tool in MCv5, maar veel krachtiger. Ik noem de scripttaal voorlopig MCSL (Model Creator Scripting Language).
MCSL volgt de syntax van C en C++ min of meer, en lijkt daardoor heel sterk op GML. Het is wel wat strenger, puntkomma's zijn verplicht en haakjes rond condities (if en while) ook. MCSL ondersteunt if, else, for, while, ... net zoals GML, er zijn alleen geen objecten of events. De taal heeft twee types: real en string, net zoals GML. Je kan ook 1D- of 2D-arrays aanmaken, en in tegenstelling tot in GML kan je ze ook doorgeven als argumenten of als returnwaarde. MCSL heeft ook 'lokale functies' die vergelijkbaar zijn met scripts in GML (ze heten 'lokaal' omdat er ook 'globale functies' zijn zoals sin, cos, random, ... die er altijd zijn).
Je kan een demo van de script parser downloaden als je het wil testen: link (Update: strings toegevoegd). Het programma start met een voorbeeldscript dat priemgetallen berekent. De script parser is nog niet volledig af: ik moet nog arrays toevoegen, voorlopig kan je dus enkel reals en strings gebruiken. En ik ben er redelijk zeker van dat er nog een hoop bugs in zitten, dus stuur maar een PM als je er één vindt :).
Een belangrijk verschil met GML is dat ik static binding en static typing gebruik. Je moet alle variabelen dus vooraf declareren en ook aangeven van welk type ze zijn. Door dit verschil is mijn scripttaal aanzienlijk sneller dan GML - volgens mijn laatste test 15 keer sneller, maar dat zal waarschijnlijk wel wat minder worden eens ik strings en arrays heb toegevoegd (meer types betekent meer dingen die doorgegeven moeten worden aan functies, dat maakt het een klein beetje trager).
8 april 2011
Ik heb nog niet zo heel veel te zeggen, ik ben nog steeds bezig met de user interface. Het ziet er ondertussen zo uit:
Voor wie het wil testen: Download
Zoals je ziet zijn er nu submenu's, hoewel er nog niet veel in staat (en geen van de knoppen in de submenu's doet op dit moment iets). De knoppen boven de submenu's kan je gebruiken om submenu's te openen of te verbergen, zodat je wat je niet nodig hebt kan verbergen en je minder lang moet zoeken naar wat je wel nodig hebt. Zoals je ziet is het venster op de screenshot niet breed genoeg om alle submenu's tegelijk weer te geven, maar je kan door met de linkermuisknop te slepen door de submenu's scrollen.
Het hoofdprogramma staat op dit moment stil, omdat ik bezig ben met de scripttaal. Het is de bedoeling dat je die uiteindelijk kan gebruiken om je eigen functies voor Model Creator te schrijven, of om dingen die met de hand heel omslachtig zijn sneller te kunnen uitvoeren. Ik heb voor de scripttaal voorlopig een klein apart programma gemaakt zodat ik het makkelijker kan testen. Op dit moment ziet het er zo uit:
In het bovenste tekstvak staat de code, in het onderste tekstvak het resultaat. Zoals je kan zien lijkt de syntax sterk op GML, maar het is wel wat strenger (de regels komen ongeveer overeen met C, C++ en Java). Je bent bijvoorbeeld verplicht om haakjes rond de conditie te zetten bij if en while. De scripttaal gebruikt static typing, dus je moet bij het declareren van variabelen aangeven van welk type ze zijn. Op dit moment is er enkel real, maar ik ga waarschijnlijk ook nog strings toevoegen, en arrays (die je wel kan doorgeven als functieargumenten).
Volgens mijn laatste test is de scripttaal ongeveer 20 keer sneller dan GML. Dat gaat waarschijnlijk wel wat minder worden eens ik strings en arrays toevoeg, maar ik verwacht dat het nog steeds aanzienlijk sneller zal zijn.
Eens de scripttaal af is, zal ik hier een demo zetten, zodat wie dat wilt het al kan testen.
4 januari 2011
Ik heb net iets toegevoegd wat ik in MCv5 al had willen doen, maar wat onmogelijk bleek te zijn in GM. Ik wilde de beelden van de views (die veel tijd kosten om te drawen) opslaan in surfaces (textures in mijn engine) zodat ik die niet telkens opnieuw moest tekenen, maar enkel als de view verplaatste of draaide of het model aangepast werd. Dat kon in GM niet omdat surfaces niet werken in 3D, maar in mijn C++ engine gaat het perfect. Dit heeft als voordeel dat het menu-gedeelte perfect blijft werken ook als je een heel zwaar model maakt (wat in MCv5 al snel problemen gaf). Bovendien gaat het draaien van één view nu veel beter omdat dit maar half zo veel rekentijd kostte als voordien (er moet maar één view hertekend worden in plaats van twee). Dit, samen met nog een paar andere optimisaties, heeft als resultaat dat ik nu modellen met 20.000 triangles kan bewerken zonder enige vertraging. Ik heb het ook eens getest met een model met 100.000 triangles. Er is nu veel vertraging (5 frames per seconde ongeveer :P), maar het is niet echt een probleem omdat het menu daar niet door vertraagd wordt.
100.000 triangles ziet er zo uit: afbeelding. Zelfs met zo'n zwaar model gebruikt het programma maar 65MB RAM (waarvan maar ongeveer de helft echt naar het model gaat, een groot deel hoort bij DirectX), dus geheugen is voorlopig ook geen probleem.
1 januari 2011
Ik heb net deze pagina aangemaakt. Ik zag dat er redelijk wat Work In Progress-blogs worden gemaakt de laatste tijd, en het leek mij wel leuk om er ook één te maken voor Model Creator. Ik heb niet de moeite gedaan blogsoftware of iets dergelijks te installeren of zelf te maken, het wordt voorlopig dus gewoon wat HTML :).
Een screenshot van Model Creator v6 zoals het er nu uitziet:
Ik ben nu al ongeveer een half jaar bezig met Model Creator v6 (niet full-time uiteraard), dus er is toch al redelijk wat af waar ik iets over kan vertellen. Ik zal beginnen bij de basis, de engine. Zoals al gezegd maak ik Model Creator v6 in C++ en niet meer in GM. Ik begon me bij MCv5 al te ergeren aan de vele beperkingen in Game Maker, en ik denk dat ik MCv5 eigenlijk niet meer veel beter kan maken als ik in GM blijf werken. Het is gewoon te traag, vraagt te veel geheugen, heeft te beperkte data structures, en het is te lastig om dingen te organiseren op een manier dat je er een jaar later nog aan uit kan. Vraag mij niet waar in de code een bepaald iets in MCv5 juist wordt gedaan, het is zo'n chaos dat ik er zelf ook een tijdje naar zou moeten zoeken. Daarom dus C++. Het belangrijkste verschil tussen iets maken in GM en in C++, is dat je in GM 2 MB aan functies hebt die je al meteen kan gebruiken, terwijl je in C++ 0 komma 0 hebt. De meest ingewikkelde standaardfuncties die je hebt in C++ zijn waarschijnlijk de wiskundige functies (sin, cos, sqrt, ...) en een aantal algoritmes voor dingen zoals het sorteren van lijsten. Meer is er niet. Er zijn natuurlijk wel de functies van Windows waarmee je vensters kan aanmaken en kan controleren of toetsen ingedrukt zijn, maar er zijn geen functies zoals draw_line (en draw_sprite kan je al helemaal vergeten). Voor ik kon beginnen moest ik dus eerst een engine maken die alle dingen doet die GM deed in MCv5, en het grootste deel daarvan gaat over DirectX (graphics zijn redelijk belangrijk in Model Creator uiteraard). Die engine is nu zo goed als af, en ik ben er redelijk tevreden mee. Ik heb alles heel low-level gehouden, waardoor de simpele dingen nu nog steeds behoorlijk wat code vragen, maar in ieder geval heb ik geen scherm vol code meer nodig om een lijn te tekenen. Alles werkt met primitives, dus dingen zoals rechthoeken en lijnen tekenen is wat omslachtig, maar dat valt best mee eens je eraan gewend bent.
Een ander heel belangrijk verschil is dat in Game Maker automatisch lijsten worden bijgehouden van de objecten die je aanmaakt, maar in C++ niet. Als je een lijst wilt, moet je zelf de pointers van die objecten bewaren in een lijst (pointers zijn vergelijkbaar met id's in GM). En je mag ook niet vergeten om die objecten weer weg te doen, want objecten worden niet automatisch verwijderd zoals in GM. Dat is in het begin ook wel even wennen.
De basis van het programma zelf is ook al klaar. Ik heb al twee views die je kan ronddraaien en bewegen, het systeem dat de punten, lijnen en vlakken tekent is zo goed als af, en ik heb ook een systeem gemaakt waarmee het toevoegen van knoppen en dergelijke heel simpel is. Dat was namelijk één van de dingen waar ik mij in MCv5 vaak aan geërgerd heb. Telkens als ik een nieuwe knop wilde toevoegen, moest ik code aanpassen op vier verschillende plaatsen:
Dat wilde ik anders doen in MCv6. De knoppen zijn nu objecten, zodat ik enkel een paar lijnen code moet toevoegen op één plaats om het object aan te maken. Ik gebruik hetzelfde systeem voor eigenlijk alle dingen die je ziet op het scherm: de views zijn objecten, en ook listboxes, textboxes, checkboxes, radio buttons en dergelijke zullen objecten zijn. Ik hoop daarmee het aanpassen van het menu wat makkelijker te maken als dat later nodig is (en ik verwacht van wel).
Goed, nu over het programma zelf. Wat is er anders dan in MCv5? Redelijk wat eigenlijk:
Om te beginnen is het sneller. Veel sneller. Het opstarten duurt misschien 0.2 seconden, dat is niet eens de moeite om een laadscherm te tonen. Vergeleken met de 5 seconden laadtijd van MCv5 is dat toch een grote verbetering vind ik zelf :P. Bovendien wordt C++ vooraf gecompileerd, en niet bij het opstarten, dus het opstarten wordt niet trager als ik meer functies toevoeg. Ook het programma zelf is duidelijk veel sneller: ik heb laatst een test gedaan met 10.000 triangles, en ik dat werkte perfect zonder enige vertraging. Ter vergelijking, MCv5 vertraagt al enorm bij 1000 triangles.
Het view-systeem werkt nu anders. In MCv5 waren er 8 types views, die overeenkwamen met de 8 knoppen die eronder stonden (top, bottom, front, back, left, right, 3D, tex). Dat was voor mij een ellende om te programmeren, want dingen die iets met de view te maken hadden (b.v. het selecteren van vertices, het verplaatsen van vertices, het drawen van de view, ...) moesten vaak 8 keer geprogrammeerd worden: één voor elk type view. Dat doe ik nu anders, er zijn nu maar twee types views: 'geometry' en 'texture'. Met texture ben ik nog niet begonnen, dus voorlopig is het enkel geometry. Dat ene type doet eigenlijk alles wat de eerste 7 types in MCv5 deden, want er zijn natuurlijk nog steeds knoppen 'front', 'top', '3D' en dergelijke. Het verschil is alleen dat enkel de camera gedraaid wordt, in plaats van dat alles anders gebeurt. Dat is iets wat ik in GM niet kon vanwege de te simpele 3D-functies. Dit heeft als groot voordeel dat alles wat in de eerste 6 types kon (zoals tekenen en verplaatsen) nu ook kan in 3D-view (in MCv5 kon je maar heel weinig in 3D-view, eigenlijk enkel het selecteren werkte volledig). Er is nu ook een grid in 3D, en je kan zelf instellen wat de oriëntatie is van het grid (X-Y-as, X-Z-as of Y-Z as).
In MCv5 kon je enkel triangles tekenen, maar dat heb ik nu uitgebreid tot alle convexe veelhoeken. Je kan dus net zo goed rechthoeken en andere veelhoeken gebruiken, wat toch wel een groot voordeel is aangezien veel modellen eerder met vierkante vlakken werken dan met driehoekige vlakken. Bovendien is het nu ook mogelijk om losse punten en losse zijden te tekenen, zonder dat daar vlakken bij horen. Dit is handig voor een aantal functies die met zijden werken in plaats van driehoeken, want in MCv5 was het niet mogelijk om echt zijden te selecteren.
Ik gebruik nu veel ingewikkeldere data structures om de geometry van het model op te slaan. In MCv5 was het model gewoon een lijst van driehoeken, nu is het een structuur van driehoeken, zijden en punten. Elke driehoek weet met welke punten en zijden het verbonden is, en elk punt en elke zijde weet ook welke driehoeken ermee verbonden zijn. Dit maakt een aantal algoritmes die in MCv5 heel veel rekentijd kostten (smooth normals bijvoorbeeld) - of gewoon onmogelijk waren - een stuk efficiënter.
MCv6 gebruikt een eigen bestandsformaat om modellen op te slaan. Het formaat dat GM gebruikt is te eenvoudig om goed mee te kunnen werken, daarom gebruik ik er nu één die ik zelf heb ontworpen. Het zal natuurlijk nog steeds mogelijk zijn om .gmmod-bestanden te importeren en exporteren. Ik heb de bestandsstructuur al grotendeels bedacht, het is gebaseerd op hoe databases werken (met tabellen, velden en rijen enzo). De reden daarvoor is dat ik het formaat forward-compatible én backward-compatible wil maken. Dat betekent dat het mogelijk zal zijn om modellen van oudere versies te openen in nieuwere versies van MCv6, maar ook omgekeerd. In dat laatste geval zal je dan wel een waarschuwing krijgen omdat sommige dingen misschien niet zullen werken in de oudere versie, maar het model zelf zal geladen kunnen worden zonder problemen. En als het laadscript ziet dat in het bestand een aantal tabellen of velden ontbreken, zal het die gewoon aanvullen met de standaardwaarde. Het nieuwe formaat is trouwens binair, waardoor het heel wat kleiner is. Bovendien gebruik ik ook zlib-compressie waardoor het nog wat kleiner wordt.
Dat is ongeveer wat ik tot nu toe heb. Meer informatie komt zodra ik meer dingen heb toegevoegd :).