Feed on
Posts
Comments

Category 'C++'

Click the post title to be able to read and write comments.

I recently got the idea to try to create a procedural shader system for DirectX 11. This basically entails that one simply throws a mesh at the shader generator and it generates a customized shader for this mesh that suits it perfectly.
I knew it is being done in high-end game engines but I had no idea how one actually does it. I spent quite a lot of time on google trying to find this, but it basically looks like some universal secret even though it actually is quite simple. So I played around with it a bit and I managed to get it to work in the end. So the follow code snippet is the procedure I used for getting it to work, probably a whole load of other ones out there.
Just hope this saves other people the same frustrations I had for a while.

void GenerateShader()
{
        ostringstream shader;

        // Basic Vertex Shader
	shader << "float4 BasicVS( float4 Pos : POSITION ) : SV_POSITION" << endl;
	shader << "{" << endl;
	shader << "	return Pos;" << endl;
	shader << "}" << endl;

        // Basic Pixel Shader
	shader << "float4 BasicPS( float4 Pos : SV_POSITION ) : SV_Target" << endl;
	shader <<"{" << endl;
	shader <<"	return float4( 1.0f, 1.0f, 1.0f, 1.0f );" << endl;
	shader <<"}" << endl;

        // A standard DirectX 10 technique
	shader << "technique10 DefaultTechnique" << endl;
	shader << "{" << endl;
	shader << "	pass p0" << endl;
	shader << "	{" << endl;
	shader << "		SetGeometryShader(NULL);" << endl;
	shader << "		SetVertexShader(CompileShader(vs_4_0, BasicVS()));" << endl;
	shader << "		SetPixelShader(CompileShader(ps_4_0, BasicPS()));" << endl;
	shader << "	}" << endl;
	shader << "}" << endl;         

        // This is where the "magic" is at. Grab the char* from your stringstream
        // and feed it into D3DCompile() along with whatever other parameters you usually send it.
        ID3DBlob* errorBlob;
        unsigned int shaderSize = shader.str().size() * sizeof(char);
        HRESULT hr = D3DCompile(shader.str().c_str(), shaderSize, "none", 0, 0, "DefaultTechnique",
                                          "fx_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &blob_, &errorBlob);
	if( FAILED(hr) )
        {
                OutputDebugStringA( (char*)errorBlob->GetBufferPointer() );
	}
	SAFE_RELEASE( errorBlob );
}

So now all that is left is 99.9% of the work to actually switch case together a shader that supports all the things your different meshes might need.
Maybe I will post something on that later when I manage to make a dent in that daunting task :p

I implemented this during a weekend, mostly because relief mapping has always interested me. Decided to toss in parallax mapping as well when I was “in the neighborhood”, and a little normal mapping for good measure as well. This is the basic implementation of both techniques with no optimizations or artifact corrections.

Here is a small code snippet. Nothing special, just don’t like to not show code.

float ray_intersect_relief(in float2 orig, in float2 dir)
{
    const float max_num_linear_steps = 20;
    const float max_num_binary_steps = 5;
    float depth = 0.0f;
    float size = 1.0f / max_num_linear_steps;
// Attempt to find the first intersection against the relief map with a linear search.
    // This is because binary search can easily miss topography.
    for(int i = 0; i < max_num_linear_steps - 1; i++)
    {
        float4 t = gTexRelief.Sample(textureSampler, orig + dir * depth);
        if(depth < t.r)
            depth += size;
    }
     // A binary search to try and find the "edge" of the closest intersection point
    for(int j = 0; j < max_num_binary_steps; j++)
    {
        size *= 0.5f;
        float4 t = gTexRelief.Sample(textureSampler, orig + dir * depth);
        if(depth < t.r)
            depth += 2*size;
        depth -= size;
    }
    return depth;
}

Objective-C Progress

I picked up a couple of books the other day to help me out with learning Objective-C, objc, and developing for the iPhone. I finished reading the objc one today, and I must say that it was very good. I had tried doing some tutorials on objc before I read this book and it generally left me with more unanswered questions than I had from the start.

Since I am a C++ programmer through and through it is tricky to pick up a new language that looks similar, but works completely different. I was having more issues with objc than with learning Python.

However, as I stated, it feels a lot better now having read the objc book. It’s named "Learn Objective-C on the Mac" and I recommend it to anyone that would wish to learn objc. However one should know that this is intended for people that already know some other programming language, so it isn’t aimed towards beginners.

The next step is to read the iPhone book, named "Beginning iPhone 3 Development: Exploring the iPhone SDK", which should prove to be equally good and even more relevant to my goal of making iPhone games (duh!).

So check back in a couple of days and maybe there is something interesting to be seen.

The development of Graphics Hardware Technology is blazing fast, with new and more improved models, that out spec the previous generations with leaps and bounds, before one has the time to digest the potential of the previous generations computing power. With the progression of this technology the computer games industry has always been quick to adapt this new power and all the features that emerge as the graphic card industry learn what the customers need from their products. The current generations of games use extraordinary visual effects to heighten the immersion into the games, all of which is thanks to the constant progress of the graphics hardware, which would have been an impossibility just a couple of years ago.

Ray tracing has been used for years in the movie industry for creation of stunning special effects and whole movies completely made in 3D. This technique for giving realistic imagery has always been for usage exclusively for non-interactive entertainment, since this way of rendering an image is extremely expensive when it comes to computations. To generate one single image with Ray Tracing you might need several hundred millions of calculations, which so far haven’t been proven to work in real-time situations, such as for games.

However, due to the continuous increase of processing power in Graphical Processing Units, GPUs, the limits of what can, and cannot, be done in real-time is constantly shifting further and further into the realm of possibility. So this thesis focuses upon finding out just how close we are to getting ray tracing into the realm of real-time games.

Two tests were performed to find out the potential a current (2009) high-end computer system has when it comes to handling a raster – ray tracing hybrid implementation. The first test is to see how well a modern GPU handles rendering of a very simple scene with phong shading and ray traced shadows without any optimizations. And the second test is with the same scenario, but this time done with a basic optimization; this last test is to illustrate the impact that possible optimizations have on ray tracers. These tests were later compared to Intel’s results with ray tracing Enemy Territory: Quake Wars.

 

If you wish to read the thesis you can find it here

This is a two player co-operative horror game that me and my classmates made as our final project in our Bachelors education in Computer Science. We also competed in the Swedish Game Awards -09 with this game.

My role in this project was as the Project Leader and the 3D Engine programmer. Since we have had bad experiences with existing 3D Engines I decided to start creating my own 3D engine for the game about 6 months before we started working on the actual game. As of the end of march 2009 the engine consisted of 12,000 LOC.

Other than this I also worked on modelling the house (which was made in 3D Studio Max) and spent much time completing our in-house Collada parser.

It features Phong Shading, Normalmapping, Skinned mesh, Level parsing from XML and the main feature is the Quadtree implementation which is shown in the middle of the clip with different colors for the different splits.

We used DirectX 9.0c for this project and the client was coded in C++.

This game and the level editor which accompanied this game (Made by a classmate) recieved a diploma for best project in the course.

Featuring Walking on terrain, multi-textured terrain, Phong shading and a basic particlesystem.

The project was made with C++ and DirectX 9.0c