Меташейдеры

1
2
3
4
5
6

struct VertexPositionNormalTexture
{
     public Vector3 Position;
     public Vector3 Normal;
     public Vector2 TextureCoordinate;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class MyBinaryWriter : BinaryWriter
{
    public void Write(Vector2 v2)
    {
        Write(v2.X);
        Write(v2.Y);
    }
    public void Write(Vector3 v3)
    {
        Write(v3.X);
        Write(v3.Y);
        Write(v3.Z);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

struct VertexPositionNormalTexture
{
    public Vector3 Position;
    public Vector3 Normal;
    public Vector2 TextureCoordinate;
 
    public void Write(MyBinaryWriter writer)
    {
        writer.Write(Position);
        writer.Write(Normal);
        writer.Write(TextureCoordinate);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Matrix GetTransform1(ref Matrix world, ref Matrix view, ref Matrix proj)
{
    Matrix result;
 
    Matrix.Multiply(ref world, ref view, out result);
    Matrix.Multiply(ref result, ref proj, out result);
 
    return result;
}
 
Matrix GetTransform2(Matrix world, Matrix view, Matrix proj)
{
    return world * view * proj;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

struct float4
{
    public CodeExpression Expression;
 
    public float4(CodeExpression expression)
    {
        this.Expression = expression;
    }
 
    public static float4 operator +(float4 left, float4 right)
    {
        CodeBinaryOperatorExpression expression;
 
        expression = new CodeBinaryOperatorExpression(
            left.Expression, CodeBinaryOperatorType.Add, right.Expression);
 
        return new float4(expression);
    }
 
    public static implicit operator float4(string argName)
    {
        return new float4(new CodeArgumentReferenceExpression(argName));
    }
 
    public override string ToString()
    {
        CSharpCodeProvider cSharp = new CSharpCodeProvider();
 
        StringBuilder hlslCode = new StringBuilder();
        StringWriter writer = new StringWriter(hlslCode);
        CodeGeneratorOptions options = new CodeGeneratorOptions();
 
        cSharp.GenerateCodeFromExpression(Expression, writer, options);
 
        return hlslCode.ToString();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

struct VSInput
{
    [POSITION]
    public float4 Position;//	: POSITION;
}
public struct CommonVSOutput
{
    public float4 Pos_ws;
    public float4 Pos_ps;
    public float4 Diffuse;
    public float3 Specular;
    public float1 FogFactor;
}
public struct VertexLightingVSOutput
{
    [POSITION] // Position in projection space
    public float4 PositionPS;//	: POSITION;
 
    [COLOR0]
    public float4 Diffuse;//	: COLOR0;
 
    [COLOR1]// Specular.rgb and fog factor
    public float4 Specular;//	: COLOR1;
}
 
public struct VertexLightingPSInput
{
    [COLOR0]
    public float4 Diffuse;//	: COLOR0;
    [COLOR1]
    public float4 Specular;//	: COLOR1;
}
public struct VertexLightingPSInputTx
{
    [COLOR0]
    public float4 Diffuse;
    [COLOR1]
    public float4 Specular;
    [TEXCOORD0]
    public float2 TexCoord;
}
 
public float1 FogStart;
public float1 FogEnd;
public float1 FogEnabled;
public float3 FogColor;  //: register(c3);
 
public texture BasicTexture;
 
private sampler TextureSampler = sampler_state(
    "BasicTexture", 
    MipFilter.Linear, 
    MinFilter.Linear, 
    MagFilter.Linear);
 
public float4x4 World;		//: register(vs, c20);	// 20 - 23
public float4x4 View;		//: register(vs, c24);	// 24 - 27
public float4x4 Projection; //: register(vs, c28);	// 28 - 31
public float3 EyePosition;	//: register(c4);	// in world space        
public float3 DiffuseColor = 1;	//: register(c5) = 1;
public float1 Alpha = 1;			//: register(c6) = 1;
public float3 EmissiveColor = 0;	//: register(c7) = 0;
public float3 SpecularColor = 1;	//: register(c8) = 1;
public float1 SpecularPower = 16;	//: register(c9) = 16;
 
 
public float1 ComputeFogFactor(float1 d)
{
    return clamp((d - FogStart) / (FogEnd - FogStart), 0, 1) * FogEnabled;
}
 
public CommonVSOutput ComputeCommonVSOutput(float4 position)
{
    CommonVSOutput vout;
 
    float4 pos_ws = mul(position, World);
    float4 pos_vs = mul(pos_ws, View);
    float4 pos_ps = mul(pos_vs, Projection);
    vout.Pos_ws = pos_ws;
    vout.Pos_ps = pos_ps;
 
    vout.Diffuse = float4(DiffuseColor.rgb + EmissiveColor, Alpha);
    vout.Specular = 0;
    vout.FogFactor = ComputeFogFactor(length(EyePosition - pos_ws));
 
    return vout;
}
 
VertexLightingVSOutput VSBasic(VSInput vin)
{
    VertexLightingVSOutput vout;
 
    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
 
    vout.PositionPS = cout.Pos_ps;
    vout.Diffuse = cout.Diffuse;
    vout.Specular = float4(cout.Specular, cout.FogFactor);
 
    return vout;
}
 
[return: COLOR]
public float4 PSBasic(VertexLightingPSInput pin)// : COLOR
{
    float4 color = pin.Diffuse + float4(pin.Specular.rgb, 0);
    color.rgb = lerp(color.rgb, FogColor, pin.Specular.w);
 
    return color;
}
 
[return:COLOR]
public float4 PSBasicTx(VertexLightingPSInputTx pin)// : COLOR
{
    float4 color = tex2D(TextureSampler, pin.TexCoord) * 
        pin.Diffuse + float4(pin.Specular.rgb, 0);
 
    color.rgb = lerp(color.rgb, FogColor, pin.Specular.w);
    return color;
}