Cool Stuff!, Game Dev Adventures!

MY FAVORITE SEASON! (Ph.D. Year 1, Week 5)

TLDR:

I wrote a very rough draft for the AISL grant. Narrowed down research questions and aims for systematic review along with a pretty comprehensive list of keywords and databases to search. I need to get the AISL proposal written up and fast. The deadline is next week and I need to somehow fit that in with my course load. Where has September gone? On the bright side, it’s officially my favorite season and my husband and I just passed our half-year wedding anniversary.

The Full Story:

Accomplishments

It’s officially my favorite season! YEAH AUTUMN! Pumpkins, cute jackets and boots, and bring on the hot chocolate! My husband and I just passed our six-month anniversary. (We’re not very good at celebrating on specific days, but we do celebrate!). We started our marriage with his favorite season — we married on the spring equinox — and now we get to celebrate the rest of our first year kicking it off with my favorite season. I picked a good wedding day. 

Last week Rogelio made me aware of the NSF’s AISL program and potential funding. AISL is “Advancing Informal STEM Learning” which is right up my games ally! He asked me to write up a 1.5-page draft proposal. We first have to compete with others from the University of Utah (each university can only submit three proposals for AISL funding). It’s final is due next week on Wednesday, Oct 2nd! Wish us luck.

With the help of my advisor, Rogelio, I narrowed down my systematic review questions, created aims, and with the help of others from the QED lab, I now also have a pretty comprehensive list of databases to search and keywords to search on. (Thanks QED lab!)

What’s next

Write up a hero narrative for the AISL. Get all my notes from the systematic review all in one place (they are a bit of everywhere right now). Somehow fit in my coursework and study for my upcoming midterms.

Roadblocks

I somehow have to fit writing up the AISL and do my research amongst many large projects from my courses. I can see now why taking three courses, two seminars, and doing research is a bit much. I am definitely feeling burnout. Mostly because one of my courses workload (just one) ate my weekend. 😦

 

Game Dev Adventures!

Down to Brass Tacks (Ph.D. Year 1, Week 4)

TLDR:

This week I got down to brass tacks (which idiom no one knows the origin of): I began an application for outside funding, and started a list of research questions to use for a systematic review. I further refined my research interests which is almost ready to be shared on the QED lab page.

The Full Story:

Accomplishments

I officially changed my name! I am now Nancy N. Blackburn. Hooray!

I have a list of several systematic review questions.

I started a dreaded application for outside funding. (They are a lot of work!)

What’s next

Do a search in the current literature to see what literary reviews have already been compiled and use that data to select a research question to move forward on.

Continue to fill out my applications for grants.

Finish my QED bio and get it published.

Roadblocks

Feeling discouraged about my applications for outside funding. The competition is stiff and while I feel that I am deserving I am definitely wondering how I “prove” my value. 

Game Dev Adventures!, Ludology

The Plan and Burnout (Ph.D. Year 1, Week 2 & 3)

TLDR:

Finished semester plan. Main two research goals are to apply for outside funding and  write a systematic review.

This week I’ll create a set of research questions for a systematic review and begin applying for outside funding.

The Full Story:

Accomplishments

I have been reading meta papers and looking at different ways to read and write different kinds of research papers. I have decided this semester to focus on writing a systematic review in the educational games/intelligent tutoring systems area.

I also shared several of the games I made in 24-48 hours with my lab and discussed the design ideas and purpose behind each. It was a good review to me. My chosen area in games is for pedagogical reasons, however games have purpose far beyond just entertainment and education.

It’s one of the other things I did this past week was defending the rigor of games research. I have come across several researchers who use game terminology without actually understanding the field of games. It is particularly important to note that what many researchers have called “game design theory” is actually gamification. Without proper understanding of the difference of game design and gamification, the application of these principles can actually backfire and undermine the overall purpose of the application as a whole. 

Two books I am enjoying delving into are Dan Norman’s The Design of Everyday Things, and Level Up! The Guide to Great Video Game Design by Scott Rogers. Part of what I want to do as part of my Ph.D. is to define and further develop design principles for learning games.

Something I realized 2.5 weeks in is that if I don’t take time between research and coursework projects to work on personal & family goals then I don’t make progress my personal or family goals. The thing is research and school is that those things can balloon and take up all your time. It’s important to set appropriate boundaries for everything and not allow those things to consume your life unknowingly. With this in mind I was able to start making progress on personal and family goals as well which has made me feel better about my life overall since I am not ignoring important aspects of myself.

Finally, I finished my semester plan and have a clearly defined path to accomplish my goals this semester.

What’s next

Create a set of research questions for a systematic review.

Begin applying for outside funding.

Roadblocks

Adhering to my scheduled time blocks to accomplish different tasks. Issues here are: under/over estimating (mostly under) time it takes to accomplish tasks, unplanned activities (such as having to spend an extra hour getting somewhere, forgetting lunch, etc.), and burnout. The burnout bit is an issue for me when I’m working against a deadline and I’m sick of doing the task in front of me.

I think I have a solution, by switching up tasks, going for walks, taking time to eat, relaxing about perfectionism (which has been a big thing for me), but when you have to get something done and you need all the time you have been given to accomplish it burnout sets in…

This semester has also been a lot heavier on the reading/analysis then expected and not so much on math and programming. I have done little programming and not in any way that I truly enjoy, and I don’t have time to make games, which makes me sad. So yeah, burn out is an issue.

Game Dev Adventures!

Ph.D. Year 1, Week 1 – Starting a Journey, GBA Workshop

TLDR:

I survived my first week of my phd, read lots of papers, attended the first ever GBA workshop at which I met lots of interesting academics, industry professionals, and peers with similar research interests, and then slept a lot (#TravelWipesMeOut).

This week I will be writing up my Ph.D. overall goals and coming up with a semester research plan. (Plus of course my coursework, but that is implied.)

A roadblock would be the need for some read/want-to-read research paper organization system suggestions, and just waiting on research papers from my advisor and contact information for people at the GBA workshop.

The Full Story:

This past week, starting 2019-08-19, I began my long journey to doctorate at the University of Utah in the School of Computing. My Ph.D. is in Computing on the HCC, Human Centered Computing, track, with a research emphasis in educational games. I started the week by attending my courses and ended the week by attending the first of its kind, GBA conference at the University of Minnesota, which made for a great start to my professional academic career, and made me a little behind in my coursework. Aw, the life of a Ph.D. Student.

As first weeks go, it was very exciting, both on the new and exciting, and scary and near panic inducing ends. For instance, because of funding and for personal reasons I am taking a more course-heavy load than typical: in all I have five courses, with one being for my research and one a required seminar for all fellowship Ph.D.s in the school of computing. As a gameplay programmer enrolled in four cs courses I was a bit taken aback that only 1.5 of my courses will be requiring programming! For the most part I will be reading and analyzing research papers in my and related fields, studying from textbooks, a little bit of math, a little bit of programming, and adjusting as best I can to Ph.D. student life.

So far so good.

I have been warned repeatedly of the cycle of a Ph.D. journey, with all its highs and lows, and I believe I have gone through the cycle multiple times this week ending on a bit of a high note.

So far so good… 😉

GBA Workshop

The GBA Workshop was very well organized, especially considering it was the first one ever. There was research presented by people in academia (from the graduate to tenured professor positions) and industry, from different disciplines (from I/O psychology to cs), and different countries (mostly U.S. and European). It was great to mingle with people from so many different backgrounds.

My favorite presentation was by a Ph.D. student at Northeastern University, Chaima Jemmali, entitled “Insights on Debugging Processes of Beginner Programmers in an Educational Puzzle Game.” Her presentation was the only one that directly correlated to the kind of research and work I want to do with my background and degrees. Specifically, she designed and programmed the game by herself and then tested it, analyzed the results, refined her project, and presented her results: a validation for using games to teach programming. I spoke with her briefly after the conference (she didn’t speak until near the end) and I hope to get to speak with her more in the future.

Accomplishments

I didn’t give up! As an industry professional turned academic I didn’t believe my experience was valued in academia, but advise from my advisor was that I should wear my experience as a badge of honor, which I did. I found that at the workshop I attended my industry experience was highly valued. I had important experience to share that all could learn and benefit from.

My main goal at the GBA workshop was to network with my peers in multiple disciplines. The conference was very interdisciplinary. I met people from I/O psychology, game design, educational games, and the social sciences, as well as people from multiple different countries (majority representation from the U.S. and Europe from my limited sample pool). There were also industry and academic professionals as well as other graduate students, both MS and Ph.D.s. Again following the advice of my advisor, I never shied away from a conversation from my fellow students (my career-stage peers), nor from beginning or experienced career and academic professionals. It was a very good first experience networking in as an academic. I’d say I killed it. Perhaps in the future I’ll share some networking tips (both that I received and that I used from experience networking professionally).

I managed to stay afloat in course-work by waking up early in my second week to do catch-up.

I have read and listened to several research papers in my broader field of research interest.

What’s next

The major two goals I have this week are:

  • Write down my Ph.D. Goal – I can revisit/revise this idea each semester
  • Write down my semester plan.

The rest of these will be part of my semester plan, some to be accomplished this week

  • Create a list of 5-7 academic/professional conferences and workshops that are related to my field. Plan to attend 1-3 of them in the coming year.
  • Start organizing/recording the papers I have been reading so I can keep track of the important things I have read and ideas for future.
  • Discuss paper ideas with my advisor. Pick one of the paper ideas and begin background and supporting paper research.
  • Start preliminary process of applying for two grants that I qualify for.
  • Start reading papers directly related to my research interests.

Roadblocks

I have been directed to two different research paper managers – I would like some guidance on organization strategies so I can track important papers.

I am also waiting on some research papers from my adviser to begin reading research related to my areas of interest.

I am awaiting contact information for people at the GBA workshop. I brought my business cards, but some of the people I spoke with didn’t have one of their own and promised to contact me. I’ll follow up once I have their contact information from the workshop organizer.

EAE 6320-001 GameEngII Game Engine Project, Game Dev Adventures!

Final Project: Matching Game!

My FINAL game: simple one-click download below, unzip, play, enjoy!

NancyNewren_ExampleGame FinalProject!

What’s new
It’s a game!

Controls
Main object: Use arrow keys to move the 3D object to its matching card.

About the Game

Okay, so it’s not pretty, but sometimes you just need to get to proof of concept; beautifying the game can come later.

When I was making educational games for Waterford Research Institute I made a lot of mini games for preK curriculum: letter/word association, number recoginition, letter matching, and even an ethics game. I really enjoyed making these simple-to-play games for 4-5 year olds. They were fun enough that even my older play testers (20-year-olds) liked them. However I never got to make a shape matching game. But now I have!

This was fun to make, especially since it was in my engine, but slightly more complicated than I anticipated.

The first thing was paring down the game to its minimum essentials: for instance having animations wouldn’t matter if I didn’t have a game first. So what was essential? Well having four objects with four matching cards. Being able to detect a right and wrong guess, and upon such guesses having a response (moving onto the next object for the right guess, feedback to let you know it was wrong otherwise). Once that was determined I simply needed to set up the graphics objects and then create the basic right/wrong logic with a simple collision detection.

Everything we needed to draw to screen was done: but any game logic I had to write, though admittedly we had previously written the player controls and the essential game loop code (like the update functions in Unity) were already supplied previous to this final assignment.

I don’t think I had noticed previously how heavily a game relies on its graphics components though. Without those, regardless of any clever logic you may have written, you don’t have much of a game. And I think it took up a majority of my time to find, create, edit, and import into my engine all the assets.

Honestly I think the most difficult thing to do was just tracking all the different assets. In game engines such as Unreal and Unity it is easier to track them I think because there are prefabs and the editor to help you create your arrays of assets. However creating the c3DObjects class to manage all things for my 3D objects (mesh, effect, texture, transform, speed, and even id) made it much simpler to program the game. When I was trying to detect whether or not an object matched a card all I had to do was give them both the same id in their c3DObject instance. Which brings up something: the cards, though flat, were still meshes. As I didn’t want them drawn like UIElements, but to interact with the objects in world space, I had them as 3DObjects. The only thing I’d add to the engine would be a UIElement class (akin to the 3DObjects class, but fancier since I’d need to track scaling vs. anchoring, etc.), and the idea of prefabs. It’d really make things easier to track with those things in place. Well, I’d also add an animation project to make animations simpler too.

The only time that I wished I’d done something different in previous assignments was the way I stored graphics elements in my game logic. Before even started coding the game I did some refractoring in my game logic to make it easier to track my graphics elements.

I created two effects for right and wrong guesses that tint and make the cards transparent. Then it was a simple matter of just swapping out the regular effect (which everything 3D was drawn with) with a right/wrong effect. That decision also made it easy to animate the ending flash as I just swapped out right and regular effects. If I’d passed the color to the effect to draw right/wrong it would have affected all my objects, and not just the one I wanted to draw.

The other difficulty was randomizing the order of everything while keeping track of them! picking four (of seven) random objects to be the match objects, making sure the four card were the four matching ones, and then drawing the four matching cards in a random order on screen. Here’s how I chose my random objects:

The collision was interesting. I didn’t do what fancy game engines do: detect whether the bounding boxes have collided. What I did was much, much simpler! Knowing that my local meshes origins were all at the origin, this meant that their position were all in world space. And as I didn’t care when their boundaries collided, but rather when their local origins were within a certain range of each other, all I needed to do was check to see if a matching object was within a certain distance of the card. To further optimize, as square roots are inefficient, I only checked the distance squared, I only checked the player object against cards that hadn’t been matched, and didn’t check for collisions at any time when the player movemnet input was deactivated. I added the DistanceSquared method to the Math::sVector class.

float distSquared = eae6320::Math::DistanceSquared(i_pObj1->m_rigidBodyState.PredictFuturePosition(i_elapsedSecondCount_sinceLastUpdate), i_pObj2->m_rigidBodyState.PredictFuturePosition(i_elapsedSecondCount_sinceLastUpdate));

return distSquared <= m_distAmountSquared;

The last thing I did was add in the sprite images upon a correct solution. This had multiple purposes: 1) it hid the no longer drawn match object, 2) It hid the sudden movement of the next object to match to the starting player position, and 3) It gave some fun, and funny, feedback to the player that they are on the right track.

If I had had more time (I did this all in about about 15-20 hours), I would have added:

  1. Movement animations
    1. For instance: Locking the “match” object to the center of the card before checking for a match, then moving it back to the beginning
  2. Setting boundaries the player can’t move outside of
  3. Beautifying the game: better match object models and cards, a better background too
  4. Add fun audio
  5. I also really wanted to do lighting

I enjoyed how it turned out though, and so did my play testers. 🙂

What I learned this semester

What I think the goal of the assignments were

I think the most important goal of the assignments was to teach us what good interfaces can do for us. For instance once we set up our one interface which behind the scenes dealt with our different platforms, we didn’t write any platform dependent code. That is very cool! We didn’t have to think about what each platform might need, instead we only connected with our interfaces and let the interfaces do their job.

We learned about building good asset pipelines. At the beginning we only had shaders, but by the end we had textures, meshes, and shaders. We separated out our algorithms from the data. I really liked this (especially creating the binary files!). Doing this makes it much faster and easier to change our assets as data is easier to update than code, and doesn’t require a recompile! We only need the built asset and that can plug-in to our code.

Another big point was to write code that is human readable, understandable, and easy to debug. Ultimately, whether it is someone else or yourself, someone is going to have to read your code to understand how to code against/interface it. If the programmer can’t understand and debug your code (which is really sad when you’re the programmer in your own code and you can’t do this!)  they’re just going to have to either spend a long time to understand it or are going to have to rewrite it, which if it’s a large amount of code is going to take a lot of time. But if you make it human understandable then they should understand quickly what is being done in the code and should be able to code/interface with it quickly, which is very important!

What I got out of this class

I learned so much this semester. I used to always be scared whenever I had to set up build dependencies and references, what the differences were, and why they mattered. I never felt like I could do it on my own. But I don’t feel afraid anymore! In fact, I learned it well enough that I was able to explain to someone else the differences and help him troubleshoot his code, and to recognize when another of my classmates had done it incorrectly in his own code. I say that not to point out that he did something wrong, as we all make mistakes, but that I know enough to know when it is done incorrectly now. And that is also not to say that it’s always easy, but I feel confident that I can figure it out, and to NOT PANIC when I get linker errors! J

I learned…

A lot about graphics for a non-graphics class (I actually understand, on a very high-level, what the graphics card does now).

A more-different way to essentially have shared pointers without the overhead of shared pointers through reference counting.

Oooh, after class one day I asked JP about how shaders do absolute value so quick and so I became aware of the intrinsic functions of the graphics card.

Also, D3D has different debug output in VS than OpenGL.

The difference between handles and pointers.

A side effect of all that we did in the code for me was using the c11 standard as I’ve never worked on projects before that used it (we were in the dark ages I suppose 😉 ).

The, unfortunately short, discussion we had about lighting was very interesting. I hadn’t thought about digital lighting as taking away light, but it made sense.

I also think I would enjoy doing graphics more than I thought I would. Every time we got into talking about graphics I got really excited. The math is pretty basic, but can also be really interesting. I really thought I would hate the discussion on lighting, but I found it fascinating.

My thoughts on good engineering architecture and design

I usually like to try to play the line between very structured and “design as you go”. However I knew there would be a lot of refractoring from assignment to assignment and there’s nothing I hate more than having to undo complicated architecture, and since I also didn’t know what the end goal was, I purposely chose to play on the side of “design as I go.” Otherwise I would have drawn out a more architectured structure. There was only one assignment that I wished I would have architected more in a previous assignment, but even in that case my friend who chose more architecture in the previous assignment only finished about an hour before me, and I know he spent more time making the architecture in the first place. So it was basically a wash.

I’ll say this about good architecture: while I was programming my game I made a decision early on to have a GetMatchObject(const unsigned int i_index) and GetCard(const unsigned int i_index) functions. This made it so that later on when I changed how I retrieved cards I only had to change it in one place: my “interface” function.

A good software architecture allows for flexibility in adding new items to the code, but isn’t so abstract and complicated that it is unclear what the interfaces are good for. I.E. it’s easy to read, understand, and debug, and allows for quick and easy iterations.

A good design will be platform independent: so that you only have to write code once! A bad design will have multiple files with only small changes in each for every platform (whether the platform is OSes, websites, or databases). A good design will allow for quick creation of new types that fit into the same interface. A bad design will require a new object or interface for each new type. A good design is faster to refractor. A bad design requires gutting of the interior for even small changes. On the other hand, a good design also isn’t over-architectured either. For instance, there is no need to create a reusable interface (no matter how neat) if you are only ever going to have one type that uses that interface. Good design is about being aware of the parts of code that need to be reusable, what needs to be able to be interfaced, and what can be done top-down as it were, because it’s not going to be used more than the once.

Acknowledgements

Thanks to Zeno for letting me bounce ideas off of him, and my Dad for proofing my write-up.

Many thanks also to my play testers who really just had fun playing: Zeno Saviour, Monika and Erik Tolman, my sister Deborah, and my brother Zeke (who tested it on linux with wine and it worked!).

EAE 6320-001 GameEngII Game Engine Project, Game Dev Adventures!

Assignment 14: Transparency in Meshes

This week’s game: simple one-click download below, unzip, play, enjoy!

NancyNewren_ExampleGame 14

What’s new
I added two transparent objects!

Controls
Main object: Use arrow keys to move main object left/right/up/down
Camera:  
Left/Right (A/D), Up/down (W/S), Zoom in/out (Q/E)

(When moving the camera things in the world will appear to move opposite. Thus when you move camera left, the world will appear to move right.)

 About the Project

This time around I added the ability to become transparent to my meshes! It was fun.

First thing was to create a shader and an effect to allow for transparency. Next I created two objects drawn with them, but drew the meshes in whatever order they were submitted to the render thread. This works fine for opaque objects, However for transparent objects when a transparent object is drawn in before an object behind it is drawn, the object behind it isn’t drawn properly (as expected that is) to the screen. I.E. you can’t see the object behind a transparent object if that object isn’t drawn before it.

This means that all transparent objects have to be drawn back to front. The order of the opaque objects doesn’t matter though (with depth buffering on at least), as long as they are drawn before all transparent objects.

So what I did to order the draw calls is: after submission to the render thread is over and and before the swap, I ordered the draw calls. How? First thing: I added the index of all opaque objects (I just asked the mesh’s effect if it was opaque, nicely of course) to a vector in the order they were submitted, and then put the transparent meshes in a separate vector with their index and their camera space z value. This is the key to quickly sorting these meshes: in camera space I immediately know which meshes are in the back and in the front based solely on their z values since camera space is when the camera is at the origin and is facing forward. Then a simple std::sort with a lambda function that orders the z’s based on z forward being negative z (i.e. larger values of z aren’t closer to the camera, they are the farthest away), quickly sorts those values. Once sorted I added the index values of the sorted transparent meshes to the end of the previously mentioned vector (the one with the opaque meshes all in front to be drawn first.) Then in the rendering of the meshes I draw them in the order of the sorted draw calls.

I chose the render thread because with my game it doesn’t really matter which thread does the sorting because it’s such a small game. However, in a real game I would profile both threads and then choose the thread that takes the least amount of time.

 Acknowledgements

I asked my brother how to use the std::sort with my vector<struct> as I hadn’t done a templated sort before . He set me on the path with the google search I needed and I whipped out a lambda compare for my sort in no time.  Thanks bro!

EAE 6320-001 GameEngII Game Engine Project, Game Dev Adventures!

Assignment 13: Build System!

This week’s game: simple one-click download below, unzip, play, enjoy!

NancyNewren_ExampleGame 13

What’s new
Nothing from the player’s perspective. Just built using my new build system!

Controls
Main object: Use arrow keys to move main object left/right/up/down
Camera:  
Left/Right (A/D), Up/down (W/S), Zoom in/out (Q/E)
(When moving the camera things in the world will appear to move opposite. Thus when you move camera left, the world will appear to move right.)

About the Project

I freaking love my new build system! It saves so much time! I have a file where I list all my graphics assets that need to be built for the game. The build system then checks this list of assets to see if they already exist, if so if there is a newer source version or if the builder itself is newer, and then it will only build if necessary. That means once I build everything (which can take several minutes) it takes less than a second to build again because my system is being smart. It’s so nice!

There are big advantages to having a list of all the assets to build in their own file: it is quick and easy to update, and you don’t have to search through other code. It’s also easy to see any bugs, and to add new features as well.

Of course this list isn’t everything that needs to be built: there are licenses and settings files that need to be copied over into the playable game folder, but the system checks for those as well. It saves so much time! Especially since we have two different platforms and two different build configuration types, which means we have to build and test for four total different build configurations. When you have to wait several minutes every time you build, every time you test a simple change, it very quickly adds up to taking hours! I’m so grateful for this new build system. Thanks JP for having us do it! 🙂

EAE 6320-001 GameEngII Game Engine Project, Game Dev Adventures!

Assignment 12: Binary Mesh Assets

Download this week’s game with the simple one-click download below! Once downloaded, unzip, play the executable, enjoy!

NancyNewren_ExampleGame 12

What’s new
Different main mesh: a Christmas cactus for my friend Felicia! Bring on the happy!

Controls
Main object: Use arrow keys to move main object left/right/up/down
Camera:  
Left/Right (A/D), Up/down (W/S), Zoom in/out (Q/E)
(When moving the camera things in the world will appear to move opposite. Thus when you move camera left, the world will appear to move right.)

About the Project

The advantage of the human readable file is that you can read, understand, and debug that file just by reading it, but they do take longer to load and are bigger files. So the idea is to load/store the assets in binary for two reasons: 1) It is more efficient (faster) to load from binary, and 2) it is also more economic (they are smaller) to store the files. So in our regular build and source files, human-readable: since a human needs to be able to interpret and debug them, but in our run-tim binary: because we’ve done all our testing and debugging and now only the computer needs to be able to read them.

There are four pieces of data that each mesh needs: number of indices, the indicies, the vertices, and the number of verticies. I chose to do the number of indicies first (since the binary read in needs to know how many indicies there are so it can jump to the next right place in the data), then the indicies next since they take up less space and are easier to read in a binary format as they are integers. Next I chose to do number of verticies, again because the read in needs to know how many vertices there are so we know the size of the memory, and then the verticies themselves. I could have done number indicies, number verticies, indicies, and then verticies, or a number of different configurations, but regardless of the order I chose, the number of indicies and verticies would always need to be stored before the index and vertex data.

Here is my floor’s binary file with the above listed order:

By default the human readable files are in OpenGL format. Previously I was swapping the UVs and winding orders after loading from the human readable files for D3D. But since I want a quick load at run time this swapping happens during the build for the binary. So the while the human readable files remain the same, the built meshes are different and cannot be swapped across platform. This does however make loading a binary file platform independent. This is how I load the binary data:

Lastly, enough talk! Let’s show the two advantages of the binary files: I made an object with 50436 index count, and 33616 vertex count. Here’s how they compare:

Human Readable File Binary
Size of file 4.61 MB 886 KB
Time to load (seconds) 0.256 0.002234

Acknowledgements

Thanks to Zeno who once again helped me with some of the C++ basics I’ve forgotten. It’s been a long time since I did file i/o with c++, and he was very helpful.

EAE 6320-001 GameEngII Game Engine Project, Game Dev Adventures!

Assignment 11: Made Mesh Assets with Maya, Added Textures to 3D Objects

Download this week’s game with the simple one-click download below! Once downloaded, unzip, play the executable, enjoy!

NancyNewren_ExampleGame 11

What’s new
Gameplay movement is the same but faster, and I updated the 3D objects’ colors and shape and added textures! Time for winter!

Controls
Main object: Use arrow keys to move main object left/right/up/down
Camera:  
Left/Right (A/D), Up/down (W/S), Zoom in/out (Q/E)
(When moving the camera things in the world will appear to move opposite. Thus when you move camera left, the world will appear to move right.)

About the Project

This week I created a Maya plugin, based on code provided to us by our professor, to export objects created in Maya to my Lua based human readable file format (which I made last week) which then imported the meshes into the game.

The Maya plugin code was a project we added to our solution called MayMeshExporter (MME). Once importing it into my code solution and assigning the proper property sheets, as well as setting the path environment variables for maya and for the maya plugin, no other settings were required (i.e. no project build dependencies nor references). This is because, while the game relies on the output from Maya via the plugin for the mesh data, the output of the MayaMeshExporter is the plugin for Maya, not the mesh data itself. So once the exporter is built we can manually export our objects, and then build the solution to have the MeshBuilder project “build” the mesh files. Essentially as long as we have some files for our meshes, either from the MME or manually made, at build time then we have what we need for our game. And since the MME doesn’t rely on any of the projects in our solution, no references were needed.

I think it’s neat that you can use Visual Studio to debug running programs. I did this with my maya plugin. Here I put a breakpoint inside the “initializePlugin” which is used to load the plugin in Maya.

I’ve used this (the attach debugger to process) frequently when debugging code for Unity and Unreal based projects.  It’s incredibly helpful to be able to step through your code this way.

With the MME working, I had a plugin to export data. So I created my plane and a new object for the player game object in Maya, set some vertex colors, and exported. This is what I had:

Maya creates more data than I was using: tangent, bitangent, texcoords, and normals. I chose to export all of them as it was a simple process to export them into my human readable file, and they are just ignored by the mesh import. I decided to do this so that if I chose to include these things in the future in my game it would be one less step I’d have to code in. This was actually helpful then when I added textures to my 3D objects…

The last thing I did was add textures to the meshes. This was a fairly straightforward process, though there were several steps involved, since I had done this previously for the UI elements, and didn’t take that long. This change touched code in graphics  (the renderer thread, meshes, and the shaders), to the game graphic objects (where the 3DObjects are stored), to the game itself, but I’m really liking the result!

After applying textures to the meshes the game looks like this:

And… it’s ready for snowfall!