I have been asked to implement a method by which a single depth value can be sampled from the depth information of a g-buffer (deferred renderer using a 32-bit floating point texture storing viewspace depth) and then this floating point value returned to system memory for storage and use in calculations on the CPU.

For example, I would like to query the centre of the screen (effectively obtaining a depth value from the centre of the depth buffer) and then pass this back to the CPU / system memory. Sadly the depth buffer is the only source of depth information I have available to query for this particular application hence the need to pull values from it rather than elsewhere.

I am limited to using DirectX9 feature set, HLSL and Shader Model 3.0.

I am looking for suggestions as to how I might achieve this. I would suspect that I have to ultimately make use of the GetRenderTargetData function at some point and suffer the inherent GPU stalls that this results in. Any other ideas or things I may have missed?

Thanks in advance for your time.

p.s. I guess I'm basically looking for a view ray->scene intersection test that returns the first hit depth value whereby the only depth information I have available is that in the g-buffer. I hope that makes sense...

This is what it looks like. I had to slow the game down to 50% speed for the gif to catch the jitter frames.

(Ignore the random vertical twitching, that's just some strange graphical bug that happens when I scale the backbuffer up too far.)

I believe the cause of this is the relative speed between the camera and the player.

In the gif, the player's speed is at 1.5, so it will alternate between moving one pixel and two pixels per frame. This causes a sort of desync between the player and camera movement which causes the jitter.

I need to be able to use decimal speeds because first of all, a speed of 1 is a bit slow for the player, and 2 is a bit fast, but also, if I add acceleration/deceleration the player's speed won't always be a whole number.

Some details:

- Nothing is rounded in-code. All positions and velocities are floats. Rounding isn't needed since nothing can move in sub-pixels. I reduced the backbuffer resolution so changing an object's position by 1 will move it one pixel. Everything is drawn at integer positions, of course.

- It's not the update order. The cycle is simple right now. The player moves, then the camera is updated. Switching the order doesn't fix the issue.

- I remembered that Cave Story has nice and smooth camera interpolation, and large pixels, so I fired it up to see what it looks like, and I was really surprised too see that it suffers the same problem. For roughly a second after the camera starts moving, the player jitters by one horizontal pixel.

My camera movement interpolation code is this:

if (camPos != playerPos) camPos += (playerPos - camPos) * strength;

Any ideas on how to fix this? I'm sure SOMEBODY has had this issue before other than me (and Pixel).

If I need to include any more relevant code snippets, just let me know. I can't really think of any that would help at the moment.

I'm working on a hexagonal grid based setup in an engine that doesn't have any kind of native support for it (in fact, I'm quite limited) - at present I'm looking to build the grid into the world shaders; projecting it downwards over the game world. This part is relatively cheap and easy and doesn't worry me. Doing more complicated stuff, such as drawing ranges (such as character movement, or weapon ranges or whatever you might expect in a 2d grid based game) by shading the appropriate tiles is seemingly quite a lot more difficult.

One suggestion that seems valid, is to draw out the selection to be shaded to a render target. Since a hexagonal grid is structured more or less the same way as a square grid, you could represent each hexagonal cell with a single pixel - meaning that a selection that is a maximum of 8x8 cells square wouldn't need to use a render target any larger than 64 total pixels.

My question is thus - how would one go about the maths to project each pixel in the render target into a hexagon in world space?

Or is there a more valid approach to my problem?

Thanks!

Luke

Thank You much appreciated. 

The application consist of class objects. I often find myself creating a "super" class to only make one instance of it. Such as a Renderer class. This class handles the window, resolution, fullscreen toggle and draws the scene.

Another class is the Asset Manager, one instance is created and it handles loading files and preparing them for later use. It keeps an array of all assets. Since the Asset Manager needs the device to create resources (VB, IB, Textures) in the managed pool, I keep a private pointer to the device in Asset Class and make a copy in the constructor. This cross object dependancy is to conform to the "rules", maybe there is a better solution?

The Entity class has one instance, it has a list of (pointers to) Player objects (struct). These player structs contain information such as what Skeleton to use, what Mesh to use, and character variables.

When rendering I pass the list of Entities to the renderer which looks up the Asset Manager for the resources and draws them as described in the Player object. 

There are also other classes such as the animator and gui but I kept those out to keep it short. Is this a good game structure? What should I pay attention to, and are there any other game structures I should consider?

The pseudo-code:

main(){
InputOutputClass IO;
DeviceClass Renderer;
AssetClass Assets(Renderer.GetDevice());
EntityClass Entities;
GuiClass Gui(Renderer.GetDevice());

MainLoop(Renderer, Assets, Entities, IO, Gui);

}

Frame 1:

Link takes out his sword and begins the attack animation. Though the sword is being rendered, it has no hitbox yet. For the next couple of frames, pressing the d-pad or any buttons will have no effect on Link. 

Frame 3:

The sword now has a hitbox and can collide with enemies.

Frame 6:

The player can now press attack to interrupt the current attack animation and start a new one. Any other input is still ignored. 

On the last frame of the animation (13), the game checks to see if the attack button is held down. If it is, Link enters a new state where he begins charging his sword. If not, on the next frame, the animation ends, the sword disappears, and full control is given back to the player.

I'm wondering, how would people approach the problem of implementing "actions" like these in a video game? Where rather than the action taking place in a single frame, it takes place over several frames and updates certain things(like the position of the sword is always attached to link's hand, even if he is moved by some outside force during the animation) each frame. With access to today's technologies of course. 

Best i can come up with for an "attack" action is hard coding it based on states. Pressing attack puts Link in the "Sword Attack" state and starts a timer. The game sees this, then creates the sword and starts playing out the animations. Each frame, the game updates, checks the time passed to see if it should add the hitbox or whatever it needs to do. The second half of the animation would have its own state, so the game knows that it is allowed to accept input for another attack to interrupt the current one.

That means coming up with a different set of states for every action in the game though, which would be a pain. Especially in a component+entity system, where you would need to add the code into a State System or something instead of each entity's  own update method.  So i'm wondering to see if there are better ways to handle this, especially more data-driven ways. 

    I'm working with an tile based terrain. The terrain is display in an isometric view. I try to limit myself to FFP because I want to target low system computers. The problem is that I tried so many light direction, the world light is so dull. The maximum bright (the surface face the light ? ) is the current texture color. Every other surface look darker. I think the surface that direct the light should get brighter than it's normal texture color! How can I achieve it with old FFP ?
I want to achieve the flat terrain surface should get lit 100% (normal texture color). the slope face the light should get brighter, the other slopes should get darker!

(same normal for 1 Triangle)

(Each vertex have its own Normal -  the edge look smooth, but the lighting even darker!)

Original Texture : 

One of the command called has to get data from database. I'm using Twistar to make things fancy.  The problem is, I need to return the result of the deferred made by the query. I know it sounds so newbie, but this is my first Twisted program, and I'm still learning.

Well, I think the scripts will make things clearer:

The server.py (don't worry, it's inside a code tag):

from twisted.application import internet, service

import protocols, services


udp_port = 10000
multicast_addr = '234.0.0.1'

dbuser = 'testuser'
dbpass = 'password'

main_service = service.MultiService()

game_service = services.GameService(dbuser, dbpass)
game_service.setServiceParent(main_service)

udp_service = internet.MulticastServer(udp_port, protocols.MulticastGameProtocol(multicast_addr, game_service), listenMultiple=True)
udp_service.setServiceParent(main_service)

application = service.Application('Simple Thing')

main_service.setServiceParent(application)

 

The protocols.py

from twisted.internet.protocol import DatagramProtocol


class MulticastGameProtocol(DatagramProtocol):

    def __init__(self, multicast_addr, service):
        self.multicast_addr = multicast_addr
        self.service = service


    def startProtocol(self):
        self.transport.setTTL(5)
        self.transport.joinGroup(self.multicast_addr)

        
    def datagramReceived(self, datagram, address):
        print 'Datagram %s received from %s' % (repr(datagram), repr(address))
        if '.' not in datagram:
            return 'Invalid command format.'

        celcommand_name, arguments = datagram.split('.', 1)
            
        self.celcommandRequestReceived(celcommand_name, arguments, address)

        
    def celcommandRequestReceived(self, celcommand_name, arguments, address):
        command_result = self.doCommand(celcommand_name, arguments)
        
        if command_result is not None:
            self.transport.write(command_result, address)

            
    def doCommand(self, celcommand_name, arguments):
        submitted_command = getattr(self, 'celcommand_%s' % (celcommand_name), None)
        
        if submitted_command is None:
            return 'Invalid command.'
            
        try:
            #return 'COMMAND SUCCESS!!!'
            return repr(submitted_command(arguments))
        except:
            #return 'Command failed.'
            return repr(submitted_command(arguments))
            
    def celcommand_login(self, arguments):
        username, password = arguments.split('.', 1)
        return self.service.login(username, password)

The services.py

from twisted.application import service
from twisted.python import log
from twisted.internet import defer

from twistar.dbobject import DBObject

class Users(DBObject):
    pass
    
class GameService(service.Service):

    def __init__(self, dbuser, dbpass):
        self.dbuser = dbuser
        self.dbpass = dbpass
        
    def startService(self):
        service.Service.startService(self)
        
        from twisted.enterprise import adbapi
        from twistar.registry import Registry

        Registry.DBPOOL = adbapi.ConnectionPool('MySQLdb', user=dbuser, passwd=dbpass, db='test')
        self.user = Users()
        
        log.msg('Made connection to database.')
        
    def login(self, username, password):
        self.loginUser = self.user.find(where=['username="%s" AND password_hash="%s"' % (username, password)], limit=1)
        self.loginUser.addCallback(self.checkLogin)
        return self.loginUser
        
    def checkLogin(self, query_result):
        if query_result is None:
            return 'Login failed!'
        else:
            print '%s logged in' % (query_result.username)
            return query_result.username
 

I'm sure the error is in the login function. I think it's like saying "Wait. My result isn't here yet" by returning a deferred, but it will be the deferred which is sent to the client.

Well, there's no complicated logic yet. I started writing this just two days ago. All I want is to send the query_result.username to the client. The query is fine. I can print that thingy on the server.

The client is just a simple client which sends 'login.Sky Warden.123'. The arguments will be separated by the '.' as well.

I think that's all. Maybe it's just me who don't fully understand deferreds, or it's just a logic hole. Or maybe both. XD

Thank you everyone.

For the last years (with pauses) I've been working on my own C++ 3d engine.

I'm using D3D9 for rendering up till today (DX11 later now, gathering knowledge and experience first).

Everything's done on a hobby basis and last months I've been working myself through basics, like brushing up C++ and 2d games.

For who's interested: http://www.crealysm.com/games/Asteroidz%20v0.3.zip.

With all knowledge gained and articles/ books read, I'm rethinking my high over 3d engine design.

I would really like to hear your thoughts and gather input, before adding more and more functionality.

Below I've tried to explain 'the basic layout'.

Any input is really appreciated, what would you do, what do you think is wrong as initial design etc.

Next steps will be

- implemening correct usage of 'const' (when passing objects by reference)

- adding an entity manager/class structure (with vectors instead of dynamic arrays, which I now do for the 'static scene')

- rethink/ design classes using inheritance, not done up till now

- make some simple demo's along the way, adjust and improvise along the way

(my apologies for using text, the VS class diagram doesn't work somehow, something about keys being added already)

TOP LEVEL: NAMESPACES (including classes, .....)

- d3drenderer (camera, font, light, mesh, mesh instance, scene, shader, skybox)

- dxinput

- dxmath (boundingbox, struct likes vectors, materials, vertices)

- game (player)

- general (FPS/ timer)

- IO (fileformat for scenes, classes for light, mesh, meshinstance etc., api independent)

- math (structs API independent, vector, indices for materials/ submeshes, colors etc.)

- renderer (scenegraph class and structs for effects/shaders, lights, materials, meshes, instances etc.)

- audio (FMod audio wrapper, class)

after it's drawn and I am still alive I want to be removed slightly as in the call of duty !!!

Basically, i'm pursuing the following goals:

1) minimal memory footprint - no string names at run-time, minimal amount of metadata if any;

2) support for hot-reloading modified shader files;

3) support for caching compiled shader bytecode and filtering out duplicates;

How are such shader libraries usually built and how should it be used in actual engine code?

Are there any more performant alternatives to DirectX effects?

The first problem can be solved by storing name hashes instead of full strings (in C++ code compile-time string hashing could be used).

The second one is tough for me, because my shader techniques can depend on global stuff (constant buffers, sampler states and shader resources) and before reloading changed technique i'll have to 'link' it (to avoid recreating those globals).

Right now, my pipeline structure conceptually looks like this:

struct Pipeline
{
              // global stuff
	Array< RenderTargetResource >		renderTargets;
	Array< DepthStencilStateResource >	depthStencilStates;
	Array< RasterizerStateResource >	rasterizerStates;
	Array< SamplerStateResource >		samplerStates;
	Array< BlendStateResource >		blendStates;
	Array< StateBlock >			stateBlocks;

	Array< CBufferResource >	constantBuffers;       //<= global constant buffers (e.g. cbPerFrame, per-view, per-instance)
             // handles to shader sampler states are stored in the 'samplerStates' array above
	Array< ShaderResource >	shaderResources;   //<= 

	Array< ShaderTechnique >	techniques;

              // all created shader programs (VS/GS/PS) for fixing-up HShaderProgram handles in technique passes (when serialized, they store indices into this array in place of handles)
	Array< HShaderProgram >	programs[ ShaderType::Count ];

	// this is used for locating shader cache on disk
	String		name;
};

// technique: name and array of passes

// pass - array of shader instances (combinations, identified by a bitmask), default shader instance id,
// and parameter bindings info (cbuffers,samplers,textures) in the form {array, start, count}

Global shader resources are shared between different shader programs, e.g. updating a global constant buffer would look so:

SetStateBlock(Default); // Default is LessEqZNoStencil, NoBlending, CullBack.

CBuffer& perFrame = pipeline.GetCBufferByName("cbPerFrame");

cbPerFrame* data = cast(cbPerFrame*) perFrame.ToPtr();

...

perFrame.Commit();

I need a piece of code that can iterate through all the four lines of the rectangle fast.

My crap code works but have 4 for-loops o_0

I would really like to avoid a separate draw call for each of these quads. From what I understand there is overhead involved in draw calls that can create a CPU bottleneck, especially considering I would only be drawing two triangles per call.

Anyone have suggestions on the most efficient way to do this?

I am not sure how many of you know about this forum:

http://ompf2.com

It started as a replacement for the great ompf forum, which focuses on ray tracing, both from an academic point of view and more hobyist oriented. Obviously you are welcome to join this forum to stay updated on the latest and greatest advances in ray tracing, both real-time and off-line.

Recently (as in: today ), we added a blog, which will provide daily (hopefully) news from ray tracing land. Url:

http://ompf2.com/blog.php

Hope to see you there,

- Jacco.

EDIT: fixed url to blog.

I figure that for something this basic, there's probably a well established way to use the same mips for sampling in the domain and pixel shaders. Can anyone point me to an article somewhere with some code examples? I'm finding articles that say you should use mip-mapping in the domain shader, but nothing as to how to do that exactly.

I am a bit confused on the aliasing problem in computer graphics(OpenGL), specifically:

1. In the picture below, the checkerboard texture is laid on a rectangle consisting of 2 triangles. Please note at the bottom of the image the jagged  edges of black and white blocks of the texture:

http://www.arcsynthesis.org/gltut/Texturing/BasicCheckerboardPlane.png

Is that problem called aliasing?

2. In the picture below, the same jagged effect can be seen on the edges of the right-most two triangles:

http://slizerboy.files.wordpress.com/2009/11/anti-alias.png?w=343&h=150

Is that the same aliasing problem?

I'm asking this because in first case, texture sampling is involved but in the second case there is no texture. 

3. If in the first example the issue is called aliasing, can we say that using linear filtering as magnification/minification filters in sampling the texture represent an anti-aliasing technique? I have searched the web for OpenGL anti-aliasing and I mostly read about "multisampling", so I'm wondering if linear and mipmap filtering can be considered anti-aliasing techniques?

I want to be a game programmer. I want to work in game company as Ubisoft, Naughty Dog..

It's my dream and I do for it everything.

It's about one year, when I start programming. I understood concept OOP, and C++ too. I've created 8 2D Games as Super Mario, Snake, Pong ...

But now, I don't know what I do next. I can go on 3D programming? If yes, which library a should use? Or I can go on Engines? Or I can stayed in 2D Game?

http://blogs.unity3d.com/2013/05/21/putting-the-power-of-unity-in-the-hands-of-every-mobile-developer/

In the past they have had offers of the Android and iOS licenses for free, looks like they are making it a permanent thing.

I've even looked up tutorials and basically copy-pasted the code from the tutorials and it still wont work.

But, I'm trying to do it the way I learned in school.

 
Matrix camRot = Matrix.CreateRotationY(mouseX * dt) * Matrix.CreateRotationX(mouseY * dt);
 
// Rotate like this?
cam *= camRot;
 
// Fix up the broken axis's
cam.Right = Vector3.Cross(cam.Forward, Vector3.Up);
cam.Right.Normalize();
 
cam.Up = Vector3.Cross(cam.Backward, cam.Right);
cam.Up.Normalize();
 
//cam.Forward = Vector3.Cross(Vector3.Up, cam.Right);
//cam.Forward.Normalize();

This code works perfectly fine for rotating left and right, but when I rotate up and down, everything is skewed and awkward looking.

I've been thinking over a problem today and I wanted to have some input from you lot!

I have a DX11 engine I'm building up and I need a system where I can load in different model types, .obj, .md5 that sorta thing. But I can't seem to come up with a way to decouple the file loading from the data itself. 

I thought I'd start here because you have much more experience than me  

This is the general Idea I have in my head. Using FileLoadingManager as a singleton and IFileImporter as an interface.

How would you do it? Design limitations?

This is a learning exercise for me so throw books, examples and whatever else you want at me too

Many Thanks.

DWORD linesCount = 4; // Draw 4 lines with one draw call
TVertex* vrts = new TVertex[linesCount]();

for(DWORD i = 0; i < linesCount; i++)
{     
     vrts[i+0].pos = v0; vrts[0].otherPos = v1;
     vrts[i+1].pos = v1; vrts[1].otherPos = v0;
     vrts[i+2].pos = v0; vrts[2].otherPos = v1;
     vrts[i+3].pos = v1; vrts[3].otherPos = v0;

     g_fThickness = 0.5f;
     vrts[i+0].thickness = D3DXVECTOR3( -g_fThickness, 0.f, g_fThickness * 0.5f );
     vrts[i+1].thickness = D3DXVECTOR3(  g_fThickness, 0.f, g_fThickness * 0.5f );
     vrts[i+2].thickness = D3DXVECTOR3(  g_fThickness, 0.f, g_fThickness * 0.5f );
     vrts[i+3].thickness = D3DXVECTOR3( -g_fThickness, 0.f, g_fThickness * 0.5f );

     vrts[i+0].texOffset = D3DXVECTOR4( g_fThickness, g_fThickness, 0.f, 0.f );
     vrts[i+1].texOffset = D3DXVECTOR4( g_fThickness, g_fThickness, 0.25f, 0.f );
     vrts[i+2].texOffset = D3DXVECTOR4( g_fThickness, g_fThickness, 0.f, 0.25f );
     vrts[i+3].texOffset = D3DXVECTOR4( g_fThickness, g_fThickness, 0.25f, 0.25f );
}

device->DrawIndexedPrimitiveUP( D3DPT_TRIANGLELIST, 0, linesCount*4, linesCount*2, indexBuffer, D3DFMT_INDEX32, vrts, sizeof( TVertex ) );

Now, I'm not sure how to fill indexBuffer, what values I should give to the index buffer?

I am trying to make my flat terrain a little bumpy and I saw Outerra's old implementation.

It looks pretty well but I couldn't figure it out. It seem POM is used but I tried lots of combinations with POM and normal mapping and I couldn't achieve that sight.

Do you have any idea about how to achieve such a perfect bumps on grass.

I have made a box filling game using python and pygame, so i know how to make UI, and the game programming. Apart from it, I know C language. I don't know JAVA and other stuff as yet, but if needed i can try that.

Phase 1: Make a GUI game, LUDO in which, 2 or 4 people can play against each other, through net login. If possible, do something so that these players can play this game through their browser, like online games are done. I saw one of my classmates implemented a version where the game would ask the ip of the computer to play against, and then these two people can play together online, but this idiot won't tell me how she did it.

Phase 2: Add another mode to the game, to play against computer. If chosen to play against the computer, the game should behave as an artificially intelligent player to play against a human.

I need help regarding this. First of all, as yet, i have decided to use python and pygame for it. But i really don't have any idea whether it's a good choice or not, how i'm going to implement these things, etc. Please suggest an approach to complete the game. Eg:- You should use this "blah blah" language, because it has "blah blah" feature, which will help you. Then you can implement it online using "blah blah" thing. also this language will make it easier for AI programming... etc. I hope you get the idea what i want to really ask. Please help.

Here ist my bar Android.mk file

LOCAL_PATH := D:/binrev/repository/bar
include $(CLEAR_VARS)

LOCAL_MODULE    := foo-prebuilt
LOCAL_SRC_FILES := external-deps/foo/lib/android/$(TARGET_ARCH_ABI)/libfoo.a
include $(PREBUILT_STATIC_LIBRARY)

include $(CLEAR_VARS)           
LOCAL_MODULE    := bar
LOCAL_C_INCLUDES:= D:/binrev/repository/bar/include
LOCAL_C_INCLUDES+= D:/binrev/repository/bar/external-deps/foo/include
LOCAL_SRC_FILES := src/bar.cpp

LOCAL_LDLIBS := -llog
LOCAL_LDLIBS += -landroid 
 
LOCAL_SHARED_LIBRARIES := foo-prebuilt
include $(BUILD_SHARED_LIBRARY)

And here is my Application.mk file:

APP_PROJECT_PATH := D:/binrev/repository/bar
APP_BUILD_SCRIPT := $(APP_PROJECT_PATH)/Android.mk 

APP_CPPFLAGS := -std=gnu++0x  
APP_CPPFLAGS += -frtti
APP_CPPFLAGS += -fexceptions
APP_CPPFLAGS += -DDEBUG  

APP_STL := gnustl_static
APP_GNUSTL_CPP_FEATURES := rtti exceptions
APP_OPTIM := debug

APP_ABI := armeabi-v7a
APP_PLATFORM:=android-10          
APP_MODULES := bar

I use MinGW64 in hanshake with NDK 8re. I could exclude MinGW64 as possible source of defects, while this failure also occurs, if I perform the build using Windows command line. While the upload is blocked by our proxy you could download the test project here:

http://sourceforge.net/projects/binrevengine/files/publications//bar.7z

I checked my sources and scripts multiple times, but can't find any failure.

I completly get lost and running out of ideas ...
Thanks for any help.

#include <iostream>
using namespace std;

class Date
{
private:
	int day, month, year;
public:
	Date(int inputDay, int inputMonth, int inputYear)
		: day(inputDay), month(inputMonth), year(inputYear){}


	bool operator== (const Date& input)
	{
		if( (day == input.day) && (month == input.month) && (year == input.year) )
			return true;
		else
			return false;
	}

	bool operator< (const Date& input)
	{
		if(year < input.year)
			return true;
		else if(month < input.month)
			return true;
		else if(day < input.day)
			return true;
		else 
			return false;
	}

	bool operator<= (const Date& input)
	{
		if(this->operator== (input))
			return true;
		else 
			return this->operator< (input);
	}

};

int main()
{
	Date d1(19 , 4, 2013);
	Date d2(19, 5, 2012);
	cout << (d1<d2) << endl;

	cin.ignore();
	return 0;
}

Btw it's me that changed the main a little - just to show what a ridiculous output I get.

Is it me or is the inequality operator coded wrong?

	bool operator< (const Date& input)
	{
		if(year < input.year)
			return true;
		else if(month < input.month)
			return true;
		else if(day < input.day)
			return true;
		else 
			return false;
	}

If it were me I'd code it like this:

	bool operator< (const Date& input)
	{
		if(year < input.year)
			return true;
		else if(year > input.year)
			return false;
		else //when year == input.year
		{
			if(month < input.month)
				return true;
			else if(month > input.month)
				return false;
			else //when month == input.month
			{
				if(day < input.day)
					return true;
				else 
					return false;
			}
		}
	}

Is it the book's example that is wrong or is it me missing something crucial?

So far everything works, things render as expected. But i'm having a hard time understanding the PrepareMesh method:

void MD5Model::PrepareMesh(MD5Mesh& mesh) {
    mesh.m_vPositionBuffer.clear();
    mesh.m_vTexCoordBuffer.clear();
    
    for (unsigned int i = 0; i < mesh.m_vVerts.size(); ++i) {
        MD5Vertex& vert = mesh.m_vVerts[i];
        
        vert.position = Vector();
        vert.normal = Vector();
        vert.position.w = 1.0f;
        vert.normal.w = 0.0f;
        
        for (int j = 0; j < vert.weightCount; ++j) {
            MD5Weight& weight = mesh.m_vWeights[vert.startWeight + j];
            MD5Joint& joint = m_vJoints[weight.jointId];
            
            Vector rotPos = joint.orientation.Inverse() * weight.position;
            vert.position += (joint.position + rotPos) * weight.bias;
        }
        
        mesh.m_vPositionBuffer.push_back(vert.position);
        mesh.m_vTexCoordBuffer.push_back(vert.uv);
    }
}

The vertex has no position before this method. From what i gather, weight.position is the position of the vertex in bone space local to the bone we're looking at. This leads me to my question, do we have one unique weight for every vertex per bone it attaches to? Or can vertices share weights?

Also, is this standard? Is there perhaps another file format that does vertex with a different approach? This seems so wasteful for some reason, but if it can't be worked around, oh well.

I've been using SDL for a few months, and have gotten quite good at it and started making my first game. But now I want my game to use hardware accelerated rendering because software rendering won't cut it any more, so I started looking into OpenGL.

Since I have some experience in SDL and kind of know what I'm doing with it, but know nothing about OpenGL, I tried to find the simplest way possible to convert my SDL surfaces to OpenGL textures and render them with OpenGL.

So I found THIS and THIS from sdltutorials.com

Following these instructions, I altered my Initialization and rendering functions from this:

bool init()
{
    if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 ) return false;

    screen = SDL_SetVideoMode( SCREEN_WIDTH , SCREEN_HEIGHT , BITS_PER_PIXEL , SDL_HWSURFACE | SDL_DOUBLEBUF );
    if( screen == NULL ) return false;
    if( Mix_OpenAudio( 44100 , MIX_DEFAULT_FORMAT , 2 , 512 ) < 0 ) return false;
    SDL_WM_SetCaption( "Test!" , NULL );
    return true;
}

SDL_Surface * load( std::string file )
{
    SDL_Surface * loaded = NULL;
    SDL_Surface * optimized = NULL;
    loaded = IMG_Load( file.c_str() );
    if( loaded != NULL )
    {
        optimized = SDL_DisplayFormatAlpha( loaded );
        SDL_FreeSurface( loaded );
    }
    return optimized;
}

void apply_surface( int x , int y , SDL_Surface * get = NULL , SDL_Surface * give = NULL , SDL_Rect * clips = NULL )
{
    SDL_Rect offsets;

    offsets.x = x;
    offsets.y = y;

    SDL_BlitSurface( get , clips , give , &offsets );
}

void apply_surface( int x , int y , SDL_Surface * get , SDL_Surface * give , int clips_x , int clips_y , int w , int h )
{
    SDL_Rect offsets;

    offsets.x = x;
    offsets.y = y;

    SDL_Rect clips;

    clips.x = clips_x;
    clips.y = clips_y;
    clips.w = w;
    clips.h = h;

    SDL_BlitSurface( get , &clips , give , &offsets );
}

...To this:

bool init()
{
    if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 ) return false;

    SDL_GL_SetAttribute(SDL_GL_RED_SIZE,8);
    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,8);
    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,8);
    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,8);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE,16);
    SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE,32);
    SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE,8);
    SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE,8);
    SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE,8);
    SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE,8);
    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,1);
    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,2);

    screen = SDL_SetVideoMode( SCREEN_WIDTH , SCREEN_HEIGHT , BITS_PER_PIXEL , SDL_HWSURFACE | SDL_GL_DOUBLEBUFFER | SDL_OPENGL );

    glClearColor(0, 0, 0, 0);
    glClearDepth(1.0f);
    glViewport(0, 0, SCREEN_WIDTH , SCREEN_HEIGHT);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0, SCREEN_WIDTH , SCREEN_HEIGHT, 0, 1, -1);
    glMatrixMode(GL_MODELVIEW);
    glEnable(GL_TEXTURE_2D);
    glLoadIdentity();

    if( screen == NULL ) return false;
    if( Mix_OpenAudio( 44100 , MIX_DEFAULT_FORMAT , 2 , 512 ) < 0 ) return false;
    SDL_WM_SetCaption( "OpenGL Test!" , NULL );
    return true;
}

SDL_Surface * load( std::string file )
{
    SDL_Surface * loaded = NULL;
    loaded = IMG_Load( file.c_str() );

    return loaded;
}

void apply_surface( int x , int y , SDL_Surface * get = NULL )
{
    GLuint textureID = 0;

    glGenTextures(1, &textureID);

    glBindTexture(GL_TEXTURE_2D, textureID);

    int Mode = GL_RGBA;

    glTexImage2D(GL_TEXTURE_2D, 0, Mode, get->w, get->h, 0, Mode, GL_UNSIGNED_BYTE, get->pixels);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();

    glBindTexture(GL_TEXTURE_2D, textureID);

    glBegin(GL_QUADS);

        glTexCoord2f(0, 0);
        glVertex2f(x, y);

        glTexCoord2f(1, 0);
        glVertex2f(x+get->w, y);

        glTexCoord2f(1, 1);
        glVertex2f(x+get->w, y+get->h);

        glTexCoord2f(0, 1);
        glVertex2f(x, y+get->h);
    glEnd();
    glDeleteTextures(1, &textureID);
    glDisable(GL_TEXTURE_2D);

    SDL_GL_SwapBuffers();
}

void apply_surface( int x , int y , SDL_Surface * get , int clips_x , int clips_y , int w , int h )
{
    GLuint textureID = 0;
    glGenTextures(1, &textureID);
    glBindTexture(GL_TEXTURE_2D, textureID);

    int Mode = GL_RGBA;

    glTexImage2D(GL_TEXTURE_2D, 0, Mode, get->w, get->h, 0, Mode, GL_UNSIGNED_BYTE, get->pixels);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();

    glBindTexture(GL_TEXTURE_2D, textureID);

    int cx = clips_x / get->w;
    int cy = clips_y / get->h;
    int cw = clips_x+w / get->w;
    int ch = clips_y+h / get->h;

    glBegin(GL_QUADS);

        glTexCoord2f(cx, cy);
        glVertex2f(x, y);

        glTexCoord2f(cx+cw, cy);
        glVertex2f(x+get->w, y);

        glTexCoord2f(cx+cw, cy+ch);
        glVertex2f(x+get->w, y+get->h);

        glTexCoord2f(cx, cy+ch);
        glVertex2f(x, y+get->h);
    glEnd();
    glDeleteTextures(1, &textureID);
    glDisable(GL_TEXTURE_2D);

    SDL_GL_SwapBuffers();
}

...But all I see when I run it is a black screen with a few glitchy rectangles flying by diagonally, and the program runs at 4 frames per second.

I will not lie, I have absolutely no idea what I'm actually doing, I just want an easy and fast way to have hardware acceleration without having to change too much of my code. I do want to learn how to properly use OpenGL eventually, but not before I at least finish my first game.

If someone can offer some advice on what I'm doing wrong, I would really appreciate it. :-)

Thank you in advance. :-)

I have a Paddle class with HandleInput(), Update(), and Draw() functions. The HandleIput and Update functions look like this at the moment.

void Paddle::HandleInput( Keyboard& keyboard )
{
    if( keyboard.KeyIsHeld( m_upKey ) )
	m_position.y -= m_moveSpeed;

    if( keyboard.KeyIsHeld( m_downKey ) )
	m_position.y += m_moveSpeed;
}

void Paddle::Update( float deltaTime )
{

}

The problem is that i want the position to be changed over time but at the moment the "Update" function is the one who is passed the delta time. It's a stupid problem but i can't figure out a nice way around it.

I want to avoid passing the delta time to the "HandleInput" function because it wouldn't really make sense, and also these function are actually an interface to a game object so it would mean passing it to every "HandleInput" function, whether it needed it or not. I could add a couple booleans to track whether either of the keys were pressed during "HandleInput" but that is essentially testing the same thing twice. I'm leaning towards the idea of adding a "delta position" variable to track the change in position, so the code would look something like this.

void Paddle::HandleInput( Keyboard& keyboard )
{
    if( keyboard.KeyIsHeld( m_upKey ) )
	m_deltaY -= m_moveSpeed;

    if( keyboard.KeyIsHeld( m_downKey ) )
	m_deltaY += m_moveSpeed;
}

void Paddle::Update( float deltaTime )
{
    m_position.y += (m_deltaY * deltaTime);
    m_deltaY = 0;
}

What do you guys think is the best solution?

I've been programming for many years, on and off, originally learning C++ and then migrating to C# when I realized how much easier it was. I absolutely love to program, but when I start to need to learn the "intermediate" or "advanced" topics of a language, I start to get discouraged and stop programming for months. I want to dedicate an hour or two of my time each day for the next year or so to just learn a language from the absolute basics to the more advanced topics. I don't just want to develop games, I want to become a programmer. I know for a fact that I'll have to learn C++ at one point in my life, but when I think about pointers, linked lists, algorithms, etc., I just want to immediately say "nope" and go back to C# where it's nice and cozy and I have someone holding my hand.

Basically, I'm relatively comfortable with both; with C++ I stopped using it when pointers were involved, and with C#, I stopped when I realized I had no idea what dictionaries do, how to do exception handling, or how to handle events. I want to become a programmer but I always get intimidated when it comes to more complicated topics and discourage myself from programming the next day. Not only that, but I can't ever find any good resources that appeal and grab my attention, and when I search on the forums, it usually has outdated recommendations that don't really work for me.

Anyways, I hope that covered where I'm at. If you have any recommendations, please feel free to throw them my way. Thanks so much!

TLDR: Stopped learning C++, went to C#, getting stuck at the "harder" subjects for both languages, and now I'm having trouble deciding if I should continue down C# or start to learn C++ now to make myself a better programmer. 

Resources.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace RPG
{
    class Resources
    {
        public Texture2D texBG;

        //Menu textures
        public Texture2D texMenuTL;
        public Texture2D texMenuTR;
        public Texture2D texMenuBL;
        public Texture2D texMenuBR;
        public Texture2D texMenuVert;
        public Texture2D texMenuHor;
        public Texture2D texMenuC;

        public SpriteFont spCustom;

        public Resources(ContentManager Content)
        {
            texBG = Content.Load<Texture2D>("bg");
            
            texMenuTL = Content.Load<Texture2D>("menu_tl");
            texMenuTR = Content.Load<Texture2D>("menu_tr");
            texMenuBL = Content.Load<Texture2D>("menu_bl");
            texMenuBR = Content.Load<Texture2D>("menu_br");
            texMenuVert = Content.Load<Texture2D>("menu_vert");
            texMenuHor = Content.Load<Texture2D>("menu_hor");
            texMenuC = Content.Load<Texture2D>("menu_c");

            spCustom = Content.Load<SpriteFont>("Custom");
        }
    }
}

Mouse.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace RPG
{
    class Mouse
    {
        MouseState previousState, currentState;
        Texture2D texture;

        public Vector2 Position
        {
            get;
            protected set;
        }

        public Rectangle Rectangle
        {
            get;
            protected set;
        }

        public bool LeftClick
        {
            get
            {
                return currentState.LeftButton == ButtonState.Pressed
                    && previousState.LeftButton == ButtonState.Released;
            }
        }

        public bool LeftPress
        {
            get
            {
                return currentState.LeftButton == ButtonState.Pressed;
            }
        }

        public bool LeftRelease
        {
            get
            {
                return !LeftPress && previousState.LeftButton == ButtonState.Pressed;
            }
        }

        public bool RightClick
        {
            get
            {
                return currentState.RightButton == ButtonState.Pressed
                    && previousState.RightButton == ButtonState.Released;
            }
        }

        public bool RightPress
        {
            get
            {
                return currentState.RightButton == ButtonState.Pressed;
            }
        }

        public bool RightRelease
        {
            get
            {
                return !RightPress && previousState.RightButton == ButtonState.Pressed;
            }
        }

        public bool NormalState
        {
            get
            {
                return !LeftPress && !LeftRelease && !RightPress && !RightRelease;
            }
        }

        public ClickableObject ClickedObject
        {
            get;
            set;
        }

        public Mouse(Texture2D texture)
        {
            this.texture = texture;
        }

        public void Update()
        {
            previousState = currentState;
            currentState = Microsoft.Xna.Framework.Input.Mouse.GetState();

            Position = new Vector2(currentState.X, currentState.Y);
            Rectangle = new Rectangle((int)Position.X, (int)Position.Y, texture.Width, texture.Height);
        }

        public void Draw(SpriteBatch spriteBatch)
        {
            if (texture != null)
            {
                spriteBatch.Begin();
                spriteBatch.Draw(texture, Position, Color.White);
                spriteBatch.End();
            }
        }
    }
}

Object.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework;

namespace RPG
{
    class Object
    {
        public Texture2D Texture
        {
            get;
            set;
        }

        private Rectangle rec;
        public Rectangle Rectangle
        {
            get
            {
                return rec;
            }
            set
            {
                rec = value;
                Position = new Vector2(Rectangle.X, Rectangle.Y);
            }
        }

        public Vector2 Position
        {
            get;
            set;
        }

        public bool Visible
        {
            get;
            set;
        }

        public Object()
        {
            Visible = true;
        }

        public void Draw(SpriteBatch spriteBatch)
        {
            if (spriteBatch != null)
                if (Texture != null)
                    spriteBatch.Draw(Texture, Position, Color.White);
        }
    }
}

ClickableObject.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace RPG
{
    public enum ObjectClickedState
    {
        Normal,
        Clicked,
        Released
    }

    class ClickableObject : Object
    {
        public ObjectClickedState LeftState
        {
            get;
            protected set;
        }

        public ObjectClickedState RightState
        {
            get;
            protected set;
        }

        public Mouse ActiveMouse
        {
            get;
            protected set;
        }

        public ClickableObject() : base()
        {
            LeftState = RightState = ObjectClickedState.Normal;
        }

        public virtual void OnLeftClick() { }
        public virtual void OnLeftPress() { }
        public virtual void OnLeftRelease() { }
        public virtual void OnLeftNormal() { }
        public virtual void OnRightClick() { }
        public virtual void OnRightPress() { }
        public virtual void OnRightRelease() { }
        public virtual void OnRightNormal() { }

        public virtual void OnHover() { }
        public virtual void OnLeave() { }

        public void Update(Mouse activeMouse)
        {
            bool intersect = activeMouse.Rectangle.Intersects(Rectangle);

            if (intersect || (ActiveMouse != null && (LeftState != ObjectClickedState.Normal || RightState != ObjectClickedState.Normal)))
            {
                ActiveMouse = activeMouse;
                ActiveMouse.ClickedObject = this;
                if (intersect)
                    OnHover();
                if (ActiveMouse.LeftPress && (LeftState == ObjectClickedState.Normal || LeftState == ObjectClickedState.Released))
                {
                    LeftState = ObjectClickedState.Clicked;
                    OnLeftClick();
                }
                else if (ActiveMouse.LeftPress && LeftState == ObjectClickedState.Clicked)
                    OnLeftPress();
                else if (ActiveMouse.LeftRelease && LeftState == ObjectClickedState.Clicked)
                {
                    LeftState = ObjectClickedState.Released;
                    OnLeftRelease();
                }
                else if (!ActiveMouse.LeftPress && LeftState == ObjectClickedState.Released)
                {
                    LeftState = ObjectClickedState.Normal;
                    OnLeftNormal();
                }

                if (ActiveMouse.RightPress && (RightState == ObjectClickedState.Normal || RightState == ObjectClickedState.Released))
                {
                    RightState = ObjectClickedState.Clicked;
                    OnRightClick();
                }
                else if (ActiveMouse.RightPress && RightState == ObjectClickedState.Clicked)
                    OnRightPress();
                else if (ActiveMouse.RightRelease && RightState == ObjectClickedState.Clicked)
                {
                    RightState = ObjectClickedState.Released;
                    OnRightRelease();
                }
                else if (!ActiveMouse.RightPress && RightState == ObjectClickedState.Released)
                {
                    RightState = ObjectClickedState.Normal;
                    OnRightNormal();
                }
            }
            else
            {
                if (ActiveMouse != null)
                {
                    ActiveMouse.ClickedObject = null;
                    ActiveMouse = null;
                    OnLeave();
                }
            }
        }
    }
}

ClickableMenu.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace RPG
{

    class ClickableMenu : ClickableObject
    {

        private SpriteFont SpriteText
        {
            get;
            set;
        }
        private Texture2D TextureTopLeft
        {
            get;
            set;
        }
        private Texture2D TextureTopRight
        {
            get;
            set;
        }
        private Texture2D TextureBottomLeft
        {
            get;
            set;
        }
        private Texture2D TextureBottomRight
        {
            get;
            set;
        }
        private Texture2D TextureVertical
        {
            get;
            set;
        }
        private Texture2D TextureHorizontal
        {
            get;
            set;
        }
        private Texture2D TextureCenter
        {
            get;
            set;
        }

        private string Title
        {
            get;
            set;
        }

        public Vector2 DragPoint
        {
            get;
            set;
        }

        List<Button> Buttons = new List<Button>();

        public ClickableMenu(Rectangle rectangle) : base()
        {
            Rectangle = rectangle;            
            Title = "Menu";
            Visible = true;
            DragPoint = new Vector2(-1, -1);
        }

        public ClickableMenu(Rectangle rectangle, string title) : base()
        {
            Rectangle = rectangle;
            Title = title;
            Visible = true;
            DragPoint = new Vector2(-1, -1);
        }

        public void Init(Resources r)
        {
            SpriteText = r.spCustom;
            TextureTopLeft = r.texMenuTL;
            TextureTopRight = r.texMenuTR;
            TextureBottomLeft = r.texMenuBL;
            TextureBottomRight = r.texMenuBR;
            TextureVertical = r.texMenuVert;
            TextureHorizontal = r.texMenuHor;
            TextureCenter = r.texMenuC;
        }

        public void AddButton(Rectangle relativeRectangle, Resources r)
        {
            Button button = new Button(this, relativeRectangle);
            button.Init(r);
            Buttons.Add(button);
        }

        public override void OnLeftPress()
        {
            if (DragPoint == new Vector2(-1, -1))
                DragPoint = new Vector2(ActiveMouse.Rectangle.X - Rectangle.X, ActiveMouse.Rectangle.Y - Rectangle.Y);
            Rectangle = new Rectangle(ActiveMouse.Rectangle.X - (int)DragPoint.X, ActiveMouse.Rectangle.Y - (int)DragPoint.Y, Rectangle.Width, Rectangle.Height);
            foreach (Button button in Buttons)
                button.Update(this);
        }

        public override void OnLeftRelease()
        {
            DragPoint = new Vector2(-1, -1);
        }

        new public void Draw(SpriteBatch spriteBatch)
        {
            if (spriteBatch != null && TextureTopLeft != null && TextureTopRight != null && TextureBottomLeft != null && TextureBottomRight != null && TextureVertical != null && TextureHorizontal != null && TextureCenter != null && Visible)
            {
                spriteBatch.Draw(TextureTopLeft, new Rectangle(Rectangle.X, Rectangle.Y, 9, 9), Color.White);
                spriteBatch.Draw(TextureVertical, new Rectangle(Rectangle.X + 9, Rectangle.Y, Rectangle.Width - 18, 9), Color.White);
                spriteBatch.Draw(TextureTopRight, new Rectangle(Rectangle.X + (Rectangle.Width - 9), Rectangle.Y, 9, 9), Color.White);
                spriteBatch.Draw(TextureHorizontal, new Rectangle(Rectangle.X, Rectangle.Y + 9, 9, Rectangle.Height - 18), Color.White);
                spriteBatch.Draw(TextureCenter, new Rectangle(Rectangle.X + 9, Rectangle.Y + 9, Rectangle.Width - 18, Rectangle.Height - 18), Color.White);
                spriteBatch.Draw(TextureHorizontal, new Rectangle(Rectangle.X + (Rectangle.Width - 9), Rectangle.Y + 9, 9, Rectangle.Height - 18), Color.White);
                spriteBatch.Draw(TextureBottomLeft, new Rectangle(Rectangle.X, Rectangle.Y + (Rectangle.Height - 9), 9, 9), Color.White);
                spriteBatch.Draw(TextureVertical, new Rectangle(Rectangle.X + 9, Rectangle.Y + (Rectangle.Height - 9), Rectangle.Width - 18, 9), Color.White);
                spriteBatch.Draw(TextureBottomRight, new Rectangle(Rectangle.X + (Rectangle.Width - 9), Rectangle.Y + (Rectangle.Height - 9), 9, 9), Color.White);
                spriteBatch.DrawString(SpriteText, Title, new Vector2(Rectangle.X + 15, Rectangle.Y + 15), Color.White);
                foreach (Button button in Buttons)
                    button.Draw(spriteBatch);
            }
        }
    }
}

Button.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace RPG
{
    class Button : ClickableObject
    {
        private SpriteFont SpriteText
        {
            get;
            set;
        }

        private string Title
        {
            get;
            set;
        }

        public Rectangle RelativeRectangle
        {
            get;
            set;
        }

        public Button(Object obj, Rectangle relativeRectangle) : base()
        {
            Rectangle = obj.Rectangle;
            RelativeRectangle = relativeRectangle;
            Visible = true;
            Title = "Button";
        }

        public Button(Object obj, Rectangle relativeRectangle, string title)
            : base()
        {
            Rectangle = obj.Rectangle;
            RelativeRectangle = relativeRectangle;
            Visible = true;
            Title = title;
        }

        public void Init(Resources r)
        {
            SpriteText = r.spCustom;
            Texture = r.texMenuC;
        }

        public void Update(Object obj)
        {
            Rectangle = obj.Rectangle;
        }

        new public void Draw(SpriteBatch spriteBatch)
        {
            if (spriteBatch != null && Texture != null && Visible)
            {
                spriteBatch.Draw(Texture, new Rectangle(Rectangle.X + RelativeRectangle.X, Rectangle.Y + RelativeRectangle.Y, RelativeRectangle.Width, RelativeRectangle.Height), Color.Black);
                spriteBatch.DrawString(SpriteText, Title, new Vector2(Rectangle.X + RelativeRectangle.X + 10, Rectangle.Y + RelativeRectangle.Y + 10), Color.White);
            }
        }
    }
}

and lastly the Game1.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace RPG
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        Resources res;

        Mouse mouse;

        ClickableMenu objMenu;

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }

        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            graphics.PreferredBackBufferWidth = 800;
            graphics.PreferredBackBufferHeight = 640;
            graphics.IsFullScreen = false;
            graphics.ApplyChanges();
            Window.Title = "RPG";
            objMenu = new ClickableMenu(new Rectangle(50, 400, 300, 200));
            base.Initialize();
        }

        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);
            res = new Resources(this.Content);
            mouse = new Mouse(Content.Load<Texture2D>("cursor"));
            objMenu.Init(res);
            objMenu.AddButton(new Rectangle(20, 60, 80, 40), res);
        }

        /// <summary>
        /// UnloadContent will be called once per game and is the place to unload
        /// all content.
        /// </summary>
        protected override void UnloadContent()
        {
        }

        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();
            mouse.Update();
            PerformUpdates();
            base.Update(gameTime);
        }

        private void PerformUpdates()
        {
            if (mouse.ClickedObject == null)
            {
                objMenu.Update(mouse);
            }
            else
            {
                mouse.ClickedObject.Update(mouse);
            }
        }

        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);
            spriteBatch.Begin();
            spriteBatch.Draw(res.texBG, new Rectangle(0, 0, 800, 640), Color.White);
            objMenu.Draw(spriteBatch);
            spriteBatch.End();
            mouse.Draw(spriteBatch);
            base.Draw(gameTime);
        }
    }
}

For example

    typedef signed   char int8;
    typedef unsigned char uint8;

    typedef signed   short int16;
    typedef unsigned short uint16;

What's the point of this?

I have a RenderWindow class who is inherited by renderer (D3D11 and OGL4).

In each of them they have a GBuffer instance and have an array to get events.

What i'm saying in my head is, only one GBuffer is needed and so it can be managed by the render window.

Same for the ortho matrix, only one is needed so it can be managed by the render window.

Is it a correct design to handle that ?

My second question is :

Do you have a nice design to handle event ? Actually I have a callback in IGameState and the MainLoop sends

each event stored for the active RenderWindow and the application manage each one.

Thanks

P.S. I've read lots of articles comparing software programming vs. game programming but it's always America or some other country. But the UK has different laws & regulations, i.e I can't imagine making a graduate work 12 hours a day with unpaid overtime would even be legal here.

srand(
 
unsigned(time(NULL)));
 
 
 
int x=0;
 
 
 
vector <int> Num_Array;
 
 
for(int i=1; i<=9; i++)
{
Num_Array.push_back(i);
}
random_shuffle(Num_Array.begin(),Num_Array.end());
player_O=Num_Array[x];
x++;

I am attempting to do some AI for a tic tac toe game.

What I'm looking to do is render a load of particles into a texture however still using the framebuffer's zbuffer which hasn't been cleared and then composite that with the main color framebuffer (which already has the scene rendered into it).
 

I've tried just not attaching the depth component to the FBO but that didn't work.

Or do I need to render the scene to a rtt, copy it's depth texture into the particles rtt depth texture and then render into the particles rtt?

Thanks

Im currently in the process of implementing shadow mapping on my engine, im using a deferred renderer for now and works just fine, my main issue comes to implementing directional lights.

I've managed to setup a ortographic matrix and multiply it with a view matrix to obtain a camera who can render the scene and draw proper shadows, the problem arises in the fact that not the entire geometry is covered in the camera range.

The solution i've read is to create the camera based on the user-controlled camera frustum, however, i do not quite understand how the ortho projection works, mainly what each parameter means, right now im using a function who takes 4 parameters, this is the code (im using the irrlicht math library for my engine as i was used to it already).

	template <class T>
	inline CMatrix4<T>& CMatrix4<T>::buildProjectionMatrixOrthoLH(
			float widthOfViewVolume, float heightOfViewVolume, float zNear, float zFar)
	{
		AX_ASSERT_IF(widthOfViewVolume==0.f); //divide by zero
		AX_ASSERT_IF(heightOfViewVolume==0.f); //divide by zero
		AX_ASSERT_IF(zNear==zFar); //divide by zero
		M[0] = (T)(2/widthOfViewVolume);
		M[1] = 0;
		M[2] = 0;
		M[3] = 0;

		M[4] = 0;
		M[5] = (T)(2/heightOfViewVolume);
		M[6] = 0;
		M[7] = 0;

		M[8] = 0;
		M[9] = 0;
		M[10] = (T)(1/(zFar-zNear));
		M[11] = 0;

		M[12] = 0;
		M[13] = 0;
		M[14] = (T)(zNear/(zNear-zFar));
		M[15] = 1;

#if defined ( USE_MATRIX_TEST )
		definitelyIdentityMatrix=false;
#endif
		return *this;
	}

I dont know what exactly each parameter means when it comes to projection, i'm also not quite sure if i need a view matrix to create the light camera, maybe someone can help me with this.

Thanks!

I started studying XNA but I am discouraged because the book tells me that XNA studio has to be installed

on any computer PC using the built app . I can't really expect that from the users .

I have some programming experience ( mostly web and database ) but i am new to games and online games .

Trying to find tutorials , books etc. best to learn from to build what I want .