Elysian Shadows

Krolgar wrote:You haven't provided many details of how you're doing your rendering. From my assumptions, however, it would seem that you're using a fixed projection matrix but resizing your viewport. Unless you make sure that your viewport's aspect ratio matches that of your orthographic projection, you are going to get some weird scaling.

glutInitWindowSize(640, 480);
...
glViewport(0, 0, 640, 480);
glOrtho(0.0f, 320, 240, 0.0f, -1.0f, 1.0f);

qpHalcy0n wrote:What we're looking for here is how you're resizing the window. This looks like initialization code. Looks like you're using glut, so there will be a glut callback "glutReshapeFunc" in which you will register a callback method that needs to be sure to readjust your aspect ratio for the viewport and the projection.

Also, you need to post as many details as you can because glOrtho is but one method to achieve the projection that you've got. There are many many ways that you have not yet explored to achieve a mapping like you've got which is why these details are important.

GLvoid resizeGL(int width, int height)
{
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	glViewport(0, 0, width, height);
	glOrtho(0.0f, 320, 240, 0.0f, -1.0f, 1.0f);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

void Graphics::drawSprite(Sprite *sprite, Rectangle to, Rectangle from, float rotate)
{
	// push the matrix so we can mess with our own
	glPushMatrix();
	glLoadIdentity();

	// translate this object to it's X and Y position
	glTranslated(to.x + to.w / 2, to.y + to.h / 2, 0);

	glBegin(GL_QUADS);
	{
		float min_x = (float) (from.x) / sprite->getWidth();
		float max_y = (float) (from.y) / sprite->getHeight();
		float max_x = (float) (from.x + from.w) / sprite->getWidth();
		float min_y = (float) (from.y + from.h) / sprite->getHeight();

		glTexCoord2f(min_x, max_y);
		glVertex2f(-to.w/2, -to.h/2);

		glTexCoord2f(max_x, max_y);
		glVertex2f(to.w/2, -to.h/2);

		glTexCoord2f(max_x, min_y);
		glVertex2f(to.w/2, to.h/2);

		glTexCoord2f(min_x, min_y);
		glVertex2f(-to.w/2, to.h/2);
	}
	glEnd();

	// translate our matrix back
	glTranslated(-to.x, -to.y, 0);

	// restore the last matrix
	glPopMatrix();
}

Rectangle r1 = { 320 / 2 - 8, 240 / 2 - 16, 16, 32 };
Rectangle r2 = { 0, 0, 16, 32 };

graphics->drawSprite(player, r1, r2, 0);

qpHalcy0n wrote:Your resize function does not reshape the parallel projection. It looks hard coded to 320x240. Be sure to adjust your projection so that it matches the new window size. (The glOrtho call)

szdarkhack wrote:I noticed that, as you said, your sprite image is 32x48, and yet in the code you posted you draw to a quad of size 16x32. If that is really the case, then the scaling issue is due to the fact that your sprite's height is 1.5 times its width, while your quad's height is 2 times it's width, thus the sprite gets stretched by a factor of 4/3 on the Y-axis.

This would also explain why setting the image size to 32x64 solved your problem. This would be the case *IF* the code you posted is actually for drawing that sprite (even though the "from" gives me some doubt). Anyway, just throwing it out there, it could be what you're looking for. BTW, you should switch your glOrtho() to use width/2.0f and height/2.0f to make sure you get the right projection for any window size, just to be safe.

Anyway, i hope that helps.

LeonBlade wrote:Oooh, I see, I wasn't aware of that; I didn't really think about it. Thank you for the explanation, hopefully if someone as stupid as me when it comes to this stuff needs help this will help them out.

Thank you szdarkhack for the explanation, and thank you everyone else who tried to help as well.