Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Terrain Rendering - mit VertexShader

Werbeanzeige

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

31

04.01.2014, 19:01

Aber es wird etwas gerendet? Wurde die Textur korrekt geladen und an den Shader übergeben?
m4studios

Sebastian Müller

Alter Hase

  • »Sebastian Müller« ist der Autor dieses Themas

Beiträge: 369

Wohnort: Freilingen [Rheinland-Pfalz]

Beruf: Schüler

  • Private Nachricht senden

32

04.01.2014, 19:02

Hier der gesamte code

HLSL-Quelltext

 
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

// *******************************************************
//************ Texturen***********************************

DWORD   NumTextures         = 1;
STRING  Texture1Filename    = "Terrain.png";
DWORD   Texture1Type        = 1; // 1: 2D-Textur; 2: Würfel; 3: Volumen
DWORD   Texture1ColorKey    = 0x00000000;
TEXTURE Texture1;

// *******************************************************
//************ Matrizen***********************************
float4x4    World;
float4x4    View;
float4x4    Prj;


// *******************************************************
//************ Sampler************************************

sampler Main_sp = sampler_state
{
Texture     = <Texture1>;
AddressU    = Wrap;
AddressV    = Wrap;
MIPFilter   = Linear;
MinFilter   = Linear;
MagFilter   = Linear;
};



// *******************************************************
//************ SHADER-Strukturen**************************

struct VS_INPUT
{
float4 Position : POSITION;
float3 Normal   : NORMAL;
float2 TexCords : TEXCOORD0;
float4 Diffuse  : COLOR0;
};

struct VS_OUTPUT        // PS_INPUT
{
float4 Position : POSITION;
float2 TexCords : TEXCOORD0;
float4 Diffuse  : COLOR0;
};



// *******************************************************
//************ Vertex-Shader Funktion*********************

VS_OUTPUT VertexShader_Main(VS_INPUT IN)
{

VS_OUTPUT OUTPUT = (VS_OUTPUT) (0);
float4  TEX = {0.0, 0.0, 0.0, 0.0};

TEX.x = IN.TexCords.x;
TEX.y = IN.TexCords.y;
TEX.z = 0;
TEX.w = 0;

// Matrizen herstellen
float4x4    WorldView = mul(World, View);
float4x4    MATRIX    = mul(WorldView, Prj);
float4      High_Map = tex2Dlod(Main_sp,TEX );
float4      Position = {0.0, 0.0, 0.0, 0.0};

Position.x += High_Map.x;
Position = mul(IN.Position, MATRIX);


OUTPUT.Position = Position;
OUTPUT.Diffuse  = IN.Diffuse;
OUTPUT.TexCords = IN.TexCords;


return OUTPUT;

}

// *******************************************************
//************ Pixel-Shader funktion**********************

float4 PixelShader_Main(VS_OUTPUT IN) : COLOR0
{
float4 Texel = {0.0, 0.0, 0.0, 1.0};    // Pixel

Texel   = tex2D(Main_sp, IN.TexCords);


return Texel;

}

// *******************************************************
//************ Technik - 1*******************************

TECHNIQUE T1
{
    PASS P1
    {
        
        VertexShader = compile vs_3_0 VertexShader_Main();
        PixelShader = compile ps_3_0 PixelShader_Main();
        
    }
    
}




Texture wird im PixelShader noch einmal auf dem Mesh erfolgreich gesampelt. Also die Texture ist korrekt geladen

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »Sebastian Müller« (04.01.2014, 23:24)

CentuCore

Frischling

Beiträge: 43

Wohnort: Wien

  • Private Nachricht senden

33

05.01.2014, 05:07

Kann es sein, dass der Wert in High_Map.x so klein ist (0, 1), dass kaum ein Veränderung bemerkbar ist?
Sprich einfach mittels Konstante skalieren lassen.

HLSL-Quelltext

 
1
2
3
4
5
6
7

extern const float g_HeightMapScale;
.
.
.
Position.x += High_Map.x * g_HeightMapScale;
//oder
High_Map *= g_HeightMapScale;

Sebastian Müller

Alter Hase

  • »Sebastian Müller« ist der Autor dieses Themas

Beiträge: 369

Wohnort: Freilingen [Rheinland-Pfalz]

Beruf: Schüler

  • Private Nachricht senden

34

05.01.2014, 10:10

Daran hat es also gelegen.

Ich habe den wert *120 genommen.

Ok. nun muss die Texturkordinaten transformieren. Also in die Bewegungsrichtung der Kamera oder?

Ich würde es folgender maßen machen.

1 . Den Bewegungsvector an den Shader senden.

2 . Die Texturekordinaten mit dem Kehrwert des Vectors multiplizieren. oder?



HLSL-Quelltext

 
1
2
3
4
5

float4          Cam_Vector;      // Bewegungsvector der kammer
float2          TexCords;          // Texturkordinaten

TexCords.x  *= -Cam_Vector.x;
TexCords.y *= -Cam_Vector.y;


ist der Ansatz korrekt?

SlinDev

Treue Seele

Beiträge: 142

Wohnort: Lübeck

Beruf: Programmierer

  • Private Nachricht senden

35

05.01.2014, 14:24

Das kannst du so machen, ansonsten bietet sich aber in deinem Fall auch an einfach die Weltkoordinaten des Vertex als Texturkoordinaten zu nutzen:

Quellcode

 
1
2
3
4
5
6

// Matrizen herstellen
float4x4    WorldView = mul(World, View);
float4x4    MATRIX    = mul(WorldView, Prj);

float4 Position = mul(IN.Position, MATRIX);
Position.y += tex2Dlod(Main_sp, float4(Position.xz, 0.0f, 0.0f)).r*g_HeightMapScale;

Sebastian Müller

Alter Hase

  • »Sebastian Müller« ist der Autor dieses Themas

Beiträge: 369

Wohnort: Freilingen [Rheinland-Pfalz]

Beruf: Schüler

  • Private Nachricht senden

36

05.01.2014, 15:05

Ich habe es mit den Texturekordinaten gemacht. Erfolgreich!!! So stark ist das "Schwimmen" auch nicht.

Jedoch habe ich keinen plan wie man die Kollision mit dem Boden Berechnen kann. Mit der heighmap oder mit Dreiecken?

Oder ein Kollisionsmodell, Jedoch ist es sehr schwer beides synchron zu verschieben. die Texturkordinaten werden mit dem Bewegungsvector der kammer verschoben. Jedoch dividiert durch 20;

HLSL-Quelltext

 
1
2

TexCords.x += Cam_Velocity.x / 20;
TexCords.y += Cam_Velocity.z / 20;

Sebastian Müller

Alter Hase

  • »Sebastian Müller« ist der Autor dieses Themas

Beiträge: 369

Wohnort: Freilingen [Rheinland-Pfalz]

Beruf: Schüler

  • Private Nachricht senden

37

07.01.2014, 00:00

Kurze frage. Ich habe irgendwo den Begriff "Geometrie - Shader" gelesen. Ich glaube es wird seit DX10 unterstützt.

Ist das ein Spezial-shader für das Terrain ?


Wenn einer von euch Terrain-Rendering mit diesem Prinzip implementiert, kann er mir vielleicht einen Ansatz zur kollisionserkennung mit hilfe der High-map oder des Mesh geben. Das wäre sehr nett, denn ich habe wirklich keinen Plan wie das ginge. Ich verlange keine 100.000 Zeilen Code. nur einen kurzen Ansatz wie man das effizient lösen kann.

Ich bin am verzweifeln. :dash: :dash: :dash:

Jonathan_Klein

Community-Fossil

Beiträge: 3 820

  • Private Nachricht senden

38

07.01.2014, 00:19

Wie schon erwähnt ist die Kollisionsabfrage komplett unabhängig davon, wie man das Terrain rendert. Die beiden Probleme haben überhaupt nichts miteinander zu tun.

Der einfachste Grundsatz wäre wohl folgender: Wenn du eine Position aus 3 Komponenten (x,y,z) hast, benutzt du x und y um in deiner Heightmap (die du beispielsweise in ein 2D-Array geladen hast) um die Terrainhöhe an dieser Position festzustellen. Lieger der z Wert darunter, befindest du dich im Terrain und hast somit eine Kollision.
Um Figuren zu bewegen ist der einfachste Ansatz ganz normal die x und y Komponente zu verändern und dann den z Wert einfach auf die passende Terrainhöhe zu setzen. Somit kommst du natürlich beliebig steile Berge hoch und fliegst auch nicht, wenn du über eine Kannte rennst, aber gut.

Etwas besser wird es, wenn du vor der Bewegung überprüfst, wo du landen würdest und schaust, wie viel höher du den Spieler setzen müsstest, damit er wieder auf dem Terrain steht. Ist dieser Wert zu hoch, verbietest du die Bewegung. Wenn die neue Position allerdings tiefer liegt, würdest du den Spieler nicht direkt runter setzten sondern quasi in der Luft schweben lassen, dann kannst du ganz normal Gravitation implementieren und ihn runterfallen lassen. Dadurch kannst du dann auch Dinge wie Springen implementieren und auch von Abhängen wirklich runterfallen, anstatt einfach direkt unten zu sein.

Du kannst aber auch ganz allgemein nach Terrain-Kollision suchen. Du kannst auch eine fertige Physikbiltiothek benutzen. Ist die Frage, wie toll es sein soll und wie viel Zeit du investieren willst (und wie viel davon selbst gemacht sein soll).
Lieber dumm fragen, als dumm bleiben!

Sebastian Müller

Alter Hase

  • »Sebastian Müller« ist der Autor dieses Themas

Beiträge: 369

Wohnort: Freilingen [Rheinland-Pfalz]

Beruf: Schüler

  • Private Nachricht senden

39

07.01.2014, 10:39

OK. Jedoch benötige ich ja diese 2D Array. oder

C-/C++-Quelltext

 
1

tbColor HeighMap[x][y];


jedoch wie kann man den die werte dort hinainsampeln. Die einzige Möglichkeit die ich kenne, um eine Texture zu sampeln ist die mit tex2D im Shader.
Jedoch muss ich dies im hauptprogramm erledigen. wie geht das genau?

Cranberry

Treue Seele

Beiträge: 312

Wohnort: Innsbruck, Tirol

  • Private Nachricht senden

40

07.01.2014, 17:14

Eine Textur ist auch nur ein 2-Dimensionaler Array.
Die kollisionsprüfung findet ja nicht im Shader statt(vielleicht im Compute-Shader aber der ist erstmal nicht wichtig). Du hast die Textur die du ja in den Shader samplest schon im Hauptprgramm.
Du checkst einfach ob die Höhe deiner Heightmap an position x y der deiner Spielfigur entspricht und wenn ja, dann gibt es eine Kollision, wenn nein wirkt Gravitation auf den Spieler.
Mein Portfolio

Werbeanzeige

Ähnliche Themen