Feed on
Posts
Comments

Tag '3D'

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;
}

So… It’s been a while.

Life is good, excluding the torment of a dying molar, and not a whole lot has happened in this time of silence. Work has been good, but has not really been related to what I wanted to write about in this blog so I opted to stay quiet for a while.

Lately I started looking at available positions in various game companies and it was somewhat upsetting to notice that you are not really suited for filling any position other than as a junior. So I basically decided that I really needed to do something about my portfolio. It was a while back that I decided this, but there was Christmas and stuff in the way so I haven’t really started doing stuff until now. Now it has begun though.

The general idea is that I will simply implement all the various things I have always wanted to try and then post the results in the portfolio section (hopefully with some binaries as well). The types of thing I will be implementing will mostly be 3D graphics related, since this is the area I always seem to find myself drooling over. But there will also be some other stuff like resource management and so on.

I have already implemented the first thing I will be putting on the portfolio (relief mapping) and it will be going up there shortly (probably not today though). Other things to be expected, in the very near future, are things like, just to name a few: Parallax mapping, Screen Space Ambient Occlusion, Deferred rendering.

If one refuses to work for any other industry one can only blame themselves for not doing everything in their power to be worthy of working there.

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.