Jump to content

  • Log In with Google      Sign In   
  • Create Account

Banner advertising on our site currently available from just $5!


1. Learn about the promo. 2. Sign up for GDNet+. 3. Set up your advert!


Prot

Member Since 05 Jul 2013
Offline Last Active Today, 08:02 AM

Topics I've Started

Pros and Cons Unity for Android

27 February 2015 - 12:45 AM

Hi,

 

I would like to start Android game developement. Apparently there are several ways to do this. The Android Studio seems to run with Eclipse and seems to be pure Java. And there is also Unity, which also enables one to develop Android games. Now I am a little confused. Does Android Studio have any advantages over Unity?

 

Here I read the following:

 

 

Unity3D uses very unique approach for doing things, most of knowledge acquired while using it, would completely non transferable to other engines. Advanced Unity3D programming is really dealing with Unity3D bugs, and finding loopholes around engine issues, nothing to do with graphics, etc - skills which would be valuable with other engines.

 

This seems to be a great disadvantage to me, or is it?

 

Is Android Studio maybe more system affiliated with Android devices or does it have richer libraries?

 

If it is not, Why would anybody pick Android Studio over Unity in case of game developement? Originally I am a C# .NET developer but I am also very comfortable with Java. So what should I consider when making this decision?


How to pass content through the project's structure efficiently?

29 January 2015 - 01:39 AM

Hi there,

 

so following situation. I have a project which is structured something like this.

 

Game1 -> GameManager -> Module1-X (so multiple instances)

 

During runtime units are being spawned in each instance of the Module class. Those Units require spritesheets for animation. Let us say each unit has a "Move", "Attack" and "Die" state, each using a individual spritesheet. This makes three Texutre2D instances per unit and with 5 different units this adds up to 15 different Texture files. Those are being passed to the unit's constructor on creation.

 

As I am loading those textures in Game1's LoadContent method I have to pass them the entire way to the Module class which then uses those textures to instaciate units.

 

Game1.LoadContent(15x textures) -> GameManager(15x textures) -> Module(15x textures) -> Unit(3x textures)

 

Imo this has several disadvantages:

  1. As far as I can judge all those 15 textures are being held in memory of the Module classes the entire time. I would like to avoid that.
  2. Also passing 15 textures through the project's entire structure makes the classes unreadable and ugly.
  3. I've got the overall feeling that this is not the way things should be done here.

In order to avoid problem #2 I created a class, its only purpose is to hold all textures that are needed in Module.cs. I called the class AnimationCollection. It holds Texture2D variables and the according getters and setters. So now my Project looks like this.

 

Game1.LoadContent(new AnimationCollection(15x textures)) -> GameManager(AnimationCollection) -> Module(AnimationCollection) -> Unit(AnimationCollection)

 

While this does seem to solve problem #2 the other problems remain.

 

Are there other options on how to handle this problem? I could think of something like loading all content in the Module Class itself, but I never saw this before. I always load my stuff in Game1.LoadContent().

 

Any ideas, suggestions or expert knowledge is highly appreciated.

 

Thanks in advance!


What is the ideal solution for a repository in my case?

07 January 2015 - 12:54 AM

I am trying to implement something similar to Scrabble or Letter Quest. I am still using XNA with C#. The game I write has to be able to check if the user input is a valid word in the dictionary. So I wonder what would be the most efficient way to implement a repository for the dictionary. I can think of two things:

 

  1. I could save all the valid words in XML files
  2. I could make the user install and use a Service-based database (SQL)

I think XML files have the disadvantage of having a poor lookup performance compared to SQL, note this is just an assumption of my own I do not know this for sure. On the other hand SQL might produce a little overhead during installation of the game if the user has no SQL Server Express installed, he will be forced to download it. Well actually the download will start automatically, still it requires a internet connection.

So what would be a good solution for this? Is there maybe another way I have not thought of? I am open to any suggestion. Also if you think that I got something wrong in my thoughts above, please let me know.

 

Btw I also was wondering how people fill dictionaries like the one in Letter Quest. I mean, are they sitting there for months inserting every single word they know into a repository?

 

Thanks in advance!


Please give me some advice for future plans.

08 September 2014 - 06:27 AM

When I had my first encounter (8 years old) with a PC I was pretty damn sure that I have to study this stuff and make it my profession. Many years later I finished studying computer science. You can't even imagine how big my disappointment was when I started looking for jobs.

 

In germany there is almost nothing to find and if you do find something it is mainly about developing browser games. My main topics in university were .NET with C# and I had plenty of time to learn XNA. But now I had to realize that nobody is looking for C# or XNA developers in the (german) gaming industry especially not for junior applicants. So I had no choice but to apply for a boring Sharepoint job (and I got it).

 

Still I did not want to accept this, so this is my plan for the future. I will go on with my current job for several years. Mainly because I think that getting a job with several years of experience is always easier. Meanwhile I started learning OpenGL.

 

Still there are some issues I am wondering about.

 

  1. It seems that nowadays nobody really needs that many game programmers (developers). I mean there is Unity, CryEngine, Unreal Engine...Does that mean that the game programmer is dying out and only the very best will find jobs in Engine developement?
  2. What are the best things I can do in order to meet the requirements for a game developer job, let's say in 2 years? By game developer job I mean everything but those freemium titles that pop everywhere! I mean want to do some real graphics/game logic programming. I hope you get the idea, it still do not have to be AAA titles but titles one can put his entire love for the medium in.

I really look forward for advice especially from people who are already in the industry.

 

Btw: The fact that I worked with C# for the most part, does not mean that I am not capable of anything else. Java, C/C++ are also languages I am pretty comfortable with. I also have experience with tools like 3Ds Max, Maya, Blender, Photoshop....


OpenGL window is not visible.

24 August 2014 - 06:39 AM

Hi there I followed the instructions to install freeglut and here for glew. I did this on my windows 7 machine and everything worked fine. Then I did the same on my windows 8 machine. I am using VS 2013 on both machines.

 

It also works and it seems to compile. But following happens:

 

1. As I created this as an empty console application the console does show up.

2. I can also see the Glut window in the system tray.

 

The problem is can not click the Glut window and I can't maximize it. There is always only the console in the foreground.

#include "glew.h"// Include the GLUT header file  
#include "GL/glut.h" // Include the GLEW header file  
#include "string.h"

struct Vector4
{
	float x;
	float y;
	float z;
	float w;
};

//GLSizei = Unsigned Integer
bool* const keyStates = new bool[256](); // Create an array of boolean values of length 256 (0-255)
bool* const keySpecialStates = new bool[256](); // Create an array of boolean values of length 256 (0-255)
bool* const keyPreviousStates = new bool[256]();

GLfloat redDiffuseMaterial[] = { 1.0, 0.0, 0.0 };
GLfloat whiteSpecularMaterial[] = { 1.0, 1.0, 1.0 };
GLfloat greenEmissiveMaterial[] = { 0.0, 1.0, 0.0 };
GLfloat blankMaterial[] = { 0.0, 0.0, 0.0 };
GLfloat mShininess[] = { 128 };


GLfloat whiteSpecularLight[] = { 1.0, 1.0, 1.0 };
GLfloat blackAmbientLight[] = { 0.0, 0.0, 0.0 };
GLfloat whiteDiffuseLight[] = { 1.0, 1.0, 1.0 };

bool diffuse = false;
bool emissive = false;
bool specular = false;

bool movingUp = false; // Whether or not we are moving up or down
float yLocation = 0.0f; // Keep track of our position on the y axis. 
float yRotationAngle = 0.0f; // The angle of rotation for our object

Vector4 bgColor = { 1.0f, 1.0f, 1.0f, 1.0f };



void renderPrimitive(void)
{
	glBegin(GL_QUADS); // Start drawing a quad primitive
	//glBegin(GL_LINE_LOOP);
	glColor3f(1.0f, 0.0f, 0.0f);
	glVertex3f(-1.0f, -1.0f, 0.0f); //Bottom Left
	glColor3f(0.0f, 1.0f, 0.0f);
	glVertex3f(-1.0f, 1.0f, 0.0f); //Top Left
	glColor3f(0.0f, 0.0f, 1.0f);
	glVertex3f(1.0f, 1.0f, 0.0f); //Top Right
	glColor3f(0.0f, 0.0f, 0.0f);
	glVertex3f(1.0f, -1.0f, 0.0f); //Bottom Right
	glEnd();
}

void keyOperations(void)
{
	if ((!keyStates['e']) && keyPreviousStates['e']) // If the 'a' key has been pressed 
	{
		// Perform 'a' key operations
		//exit(0);
		/*bgColor.x = 1.0f;
		bgColor.y = .0f;
		bgColor.z = .0f;*/

	}
}


void keySpecialOperations(void)
{
	if (keySpecialStates[GLUT_KEY_LEFT]) // If the left arrow key has been pressed
	{
		// Perform left arrow key operations
	}
}

void moveObject(void)
{
	if (movingUp) // If we are moving up
	{
		yLocation -= 0.0025f; // Move up along our yLocation
	}
	else // Otherwise
	{
		yLocation += 0.0025f; // Move down along our yLocation 
	}

	if (yLocation < -3.0f) // If we have gone up too far
	{
		movingUp = false; // Reverse our direction so we are moving down
	}
	else if (yLocation > 3.0f) // Else if we have gone down too far
	{
		movingUp = true; // Reverse our direction so we are moving up
	}

	yRotationAngle += 0.005f; // Increment our rotation value
	if (yRotationAngle > 360.0f) // If we have rotated beyond 360 degrees (a full rotation)
	{
		yRotationAngle = 0.0f; // Subtract 360 degrees off of our rotation
	}
}

void light(void)
{
	glLightfv(GL_LIGHT0, GL_SPECULAR, whiteSpecularLight);
	glLightfv(GL_LIGHT0, GL_AMBIENT, blackAmbientLight);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, whiteDiffuseLight);
}

void cubeWireCustom(void)
{
	glTranslatef(0.0f, yLocation, -5.0f);
	glRotatef(yRotationAngle, 0.0f, 1.0f, 0.0f);
	glColor4f(1.0f, 0.0f, 0.0f, 0.5f);
	glScalef(0.5f, 1.0f, 2.0f);
	glutSolidCube(2.0f);
	glutWireCube(2.0f);
}

void display(void) {

	moveObject();
	keyOperations();
	keySpecialOperations();

	glEnable(GL_BLEND); // Enable the OpenGL Blending functionality
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Set the blend mode to blend our current RGBA with what is already in the buffer

	glClearColor(bgColor.x, bgColor.y, bgColor.z, bgColor.w);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //Clear the colour buffer (more buffers later on)  
	glLoadIdentity(); // Load the Identity Matrix to reset our drawing locations  
	gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
	light();
	glTranslatef(0.0f, 0.0f, -5.0f); // Push eveything 5 units back into the scene, otherwise we won't see the primitive

	//renderPrimitive();

	cubeWireCustom();

	//renderPrimitive(); //render the primitive	
	//glutWireCube(2.0f);	
	//glutWireSphere(2.0f,20,20);
	//glutWireTeapot(2.0f);	
	//glutSolidTeapot(2.0f);
	glutSwapBuffers(); //Swap our buffers

	memcpy(keyPreviousStates, keyStates, 256 * sizeof(bool));

}

void reshape(int width, int height)
{
	glViewport(0, 0, (GLsizei)width, (GLsizei)height); // Set our viewport to the size of our window. (0,0) being bottom left in the window.
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity(); // Reset the projection matrix to the identity matrix so that we don't get any artifacts (cleaning up)
	gluPerspective(60, (GLfloat)width / (GLfloat)height, 1.0, 100.0); // Set the Field of view angle (in degrees), the aspect ratio of our window, and the new and far planes
	glMatrixMode(GL_MODELVIEW);
}

void keyPressed(unsigned char key, int x, int y)
{
	keyStates[key] = true; //Set the state of the current key to pressed	

	if (key == 's')
	{
		if (!specular)
		{
			specular = true;
			glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, whiteSpecularMaterial);
			glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mShininess);
		}
		else if (specular)
		{
			specular = false;
			glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, blankMaterial);
			glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, blankMaterial);
		}
	}

	if (key = 'd')
	{
		if (!diffuse)
		{
			diffuse = true;
			glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, redDiffuseMaterial);
		}
		else if (diffuse)
		{
			diffuse = false;
			glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, blankMaterial);
		}
	}

	if (key == 'e')
	{
		if (!emissive)
		{
			emissive = true;
			glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, greenEmissiveMaterial);
		}
		else if (emissive)
		{
			emissive = true;
			glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, blankMaterial);
		}
	}

}

void keyUp(unsigned char key, int x, int y)
{
	keyStates[key] = false; //Set the state of the current key to not pressed
}

void keySpecial(int key, int x, int y)
{
	keySpecialStates[key] = true;
}

void keySpecialUp(int key, int x, int y)
{
	keySpecialStates[key] = false;
}

void init()
{
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_LIGHTING);
	glEnable(GL_COLOR_MATERIAL);
	glEnable(GL_LIGHT0);
}



int main(int argc, char **argv) {
	glutInit(&argc, argv); // Initialize GLUT  
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); // Set up a basic display buffer (now double buffered)   
	glutInitWindowSize(500, 500); // Set the width and height of the window  
	glutInitWindowPosition(2500, 100); // Set the position of the window  
	glutCreateWindow("Your first OpenGL Window"); // Set the title for the window  

	init();

	glutDisplayFunc(display); // Tell GLUT to use the method "display" for rendering  
	glutIdleFunc(display); // Tell GLUT to use the method "display" as our idle method as well
	glutReshapeFunc(reshape); // Tell GLUT to use the method "reshape" for reshaping
	glutKeyboardFunc(keyPressed); // Tell GLUT to use the method "keyPressed" for key presses 
	glutKeyboardUpFunc(keyUp); // Tell GLUT to use the method "keyUp" for key up events  
	glutSpecialFunc(keySpecial); // Tell GLUT to use the method "keySpecial" for special key presses
	glutSpecialUpFunc(keySpecialUp); // Tell GLUT to use the method "keySpecialUp" for special up key events	
	glutMainLoop(); // Enter GLUT's main loop  
}

Please tell me if you need more information.


PARTNERS