BGRABitmap tutorial 16/de: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		Dieses Tutorial zeigt Ihnen, wie Sie Texturen an 3D-Objekten anwenden.
2	2
3	3		## Texturen erzeugen
4	4
5	5		Zum Erzeugen der Texturen, benutzen wir die folgende Unit. Wie diese funktioniert, können Sie im [[BGRABitmap tutorial 8/de\|Texturen-Tutorial]] nachlesen. Hier ist die Unit :
6	6
7	7		``` pascal
8	8		unit utexture;
9	9
10	10		{$mode objfpc}{$H+}
11	11
12	12		interface
13	13
14	14		uses
15	15		Classes, SysUtils, BGRABitmap, BGRABitmapTypes;
16	16
17	17		function CreateGrassTexture(tx,ty: integer): TBGRABitmap;
18	18		function CreateVerticalWoodTexture(tx, ty: integer): TBGRABitmap;
19	19		function CreateWoodTexture(tx,ty: integer): TBGRABitmap;
20	20
21	21		implementation
22	22
23	23		uses BGRAGradients;
24	24
25	25		function Interp256(value1,value2,position: integer): integer; inline;
26	26		begin
27	27		result := (value1(256-position)+value2position) shr 8;
28	28		end;
29	29
30	30		function Interp256(color1,color2: TBGRAPixel; position: integer): TBGRAPixel; inline;
31	31		begin
32	32		result.red := Interp256(color1.red,color2.red,position);
33	33		result.green := Interp256(color1.green,color2.green,position);
34	34		result.blue := Interp256(color1.blue,color2.blue,position);
35	35		result.alpha := Interp256(color1.alpha,color2.alpha,position);
36	36		end;
37	37
38	38		function CreateWoodTexture(tx,ty: integer): TBGRABitmap;
39	39		var
40	40		colorOscillation, globalColorVariation: integer;
41	41		p: PBGRAPixel;
42	42		i: Integer;
43	43		begin
44	44		result := CreateCyclicPerlinNoiseMap(tx,ty,1.5,1.5,1,rfBestQuality);
45	45		p := result.Data;
46	46		for i := 0 to result.NbPixels-1 do
47	47		begin
48	48		colorOscillation := round(sqrt((sin(p^.redPi/16)+1)/2)256);
49	49		globalColorVariation := p^.red;
50	50		p^:= Interp256( Interp256(BGRA(247,188,120),BGRA(255,218,170),colorOscillation),
51	51		Interp256(BGRA(157,97,60),BGRA(202,145,112),colorOscillation), globalColorVariation);
52	52		inc(p);
53	53		end;
54	54		end;
55	55
56	56		function CreateVerticalWoodTexture(tx, ty: integer): TBGRABitmap;
57	57		var
58	58		globalPos: single;
59	59		colorOscillation, globalColorVariation: integer;
60	60		p: PBGRAPixel;
61	61		i: Integer;
62	62		x,nbVertical: integer;
63	63		begin
64	64		result := CreateCyclicPerlinNoiseMap(tx,ty,1,1,1,rfBestQuality);
65	65		p := result.Data;
66	66		x := 0;
67	67		nbVertical := tx div 128;
68	68		if nbVertical = 0 then nbVertical := 1;
69	69		for i := 0 to result.NbPixels-1 do
70	70		begin
71	71		globalPos := p^.redPi/32 + nbVerticalx2Pi/tx*8;
72	72		colorOscillation := round(sqrt((sin(globalPos)+1)/2)*256);
73	73		globalColorVariation := p^.red; //round(sin(globalPos/8)*128+128);
74	74		p^:= Interp256( Interp256(BGRA(247,188,120),BGRA(255,218,170),colorOscillation),
75	75		Interp256(BGRA(157,97,60),BGRA(202,145,112),colorOscillation), globalColorVariation);
76	76		inc(p);
77	77		inc(x);
78	78		if x = tx then x := 0;
79	79		end;
80	80		end;
81	81
82	82		function CreateGrassTexture(tx,ty: integer): TBGRABitmap;
83	83		var
84	84		p: PBGRAPixel;
85	85		i: Integer;
86	86		begin
87	87		result := CreateCyclicPerlinNoiseMap(tx,ty,1,1,1,rfBestQuality);
88	88		p := result.Data;
89	89		for i := 0 to result.NbPixels-1 do
90	90		begin
91	91		p^ := Interp256( BGRA(0,128,0), BGRA(192,255,0), p^.red );
92	92		inc(p);
93	93		end;
94	94		end;
95	95
96	96		end.
97	97		```
98	98
99	99		## Holzwürfel auf dem Gras
100	100
101	101		Hier ist eine Unit die eine Szene erzeugt mit einem Flecken Gras und darauf einem Würfel aus Holz:
102	102
103	103		``` pascal
104	104		unit ex2;
105	105
106	106		{$mode objfpc}{$H+}
107	107
108	108		interface
109	109
110	110		uses
111	111		Classes, SysUtils, BGRAScene3D, BGRABitmap, BGRABitmapTypes;
112	112
113	113		type
114	114		{ TExample2 }
115	115
116	116		TExample2 = class(TBGRAScene3D)
117	117		grass,wood,vWood: TBGRABitmap;
118	118
119	119		constructor Create;
120	120		procedure ApplyTexCoord(face: IBGRAFace3D; Times: integer = 2);
121	121		procedure Render; override;
122	122		destructor Destroy; override;
123	123		end;
124	124
125	125		implementation
126	126
127	127		uses utexture;
128	128
129	129		const texSize = 128;
130	130
131	131		{ TExample2 }
132	132
133	133		constructor TExample2.Create;
134	134		var
135	135		base,v: array of IBGRAVertex3D;
136	136		box : IBGRAObject3D;
137	137		begin
138	138		inherited Create;
139	139
140	140		//erzeugt die Texturen
141	141		grass := CreateGrassTexture(texSize,texSize);
142	142		vWood := CreateVerticalWoodTexture(texSize,texSize);
143	143		wood := CreateWoodTexture(texSize,texSize);
144	144
145	145		//erzeugt den Boden
146	146		with CreateObject(grass) do
147	147		begin
148	148		base := MainPart.Add([-50,20,-50, -50,20,50, 50,20,50, 50,20,-50]);
149	149		ApplyTexCoord(AddFace(base),4);
150	150		end;
151	151
152	152		//erzeugt die Holzkiste
153	153		box := CreateObject(vWood);
154	154		with box do
155	155		begin
156	156		v := MainPart.Add([-1,-1,-1, 1,-1,-1, 1,1,-1, -1,1,-1,
157	157		-1,-1,+1, 1,-1,+1, 1,1,+1, -1,1,+1]);
158	158
159	159		ApplyTexCoord(AddFace([v[0],v[1],v[2],v[3]]));
160	160		ApplyTexCoord(AddFace([v[4],v[5],v[1],v[0]],wood));
161	161		ApplyTexCoord(AddFace([v[7],v[6],v[5],v[4]]));
162	162		ApplyTexCoord(AddFace([v[3],v[2],v[6],v[7]],wood));
163	163		ApplyTexCoord(AddFace([v[1],v[5],v[6],v[2]]));
164	164		ApplyTexCoord(AddFace([v[4],v[0],v[3],v[7]]));
165	165
166	166		MainPart.Scale(20);
167	167		end;
168	168		//RemoveObject(box);
169	169
170	170		ViewPoint := Point3D(-40,-40,-100);
171	171		end;
172	172
173	173		procedure TExample2.ApplyTexCoord(face: IBGRAFace3D; Times: integer);
174	174		begin
175	175		with face do
176	176		begin
177	177		TexCoord[0] := PointF(0,0);
178	178		TexCoord[1] := PointF(texSize*Times-1,0);
179	179		TexCoord[2] := PointF(texSizeTimes-1,texSizeTimes-1);
180	180		TexCoord[3] := PointF(0,texSize*Times-1);
181	181		end;
182	182		end;
183	183
184	184		procedure TExample2.Render;
185	185		begin
186	186		inherited Render;
187	187		end;
188	188
189	189		destructor TExample2.Destroy;
190	190		begin
191	191		grass.free;
192	192		wood.free;
193	193		vWood.free;
194	194		inherited Destroy;
195	195		end;
196	196
197	197		end.
198	198		```
199	199
200	200		Zuerst werden die benötigten Texturen erzeugt. Der Grasflecken ist ein Objekt mit Grastextur, festgelegt durch 4 Kanten. Die Textur ist als Parameter der Funktion "CreateObject" festgelegt. "AddFace" gibt ein IBGRAFace3D-Objekt zurück, das an die benutzerdefinierte Prozedur "ApplyTexCoord" weitergegeben wird. Diese Prozedur setzt die Eigenschaft "TexCoord" einen jeden Kante der Fläche. Diese Koordinaten sind pixelzentrierte Fließkommakoordinaten.
201	201
202	202		Die hölzerne Kiste wird als Objekt mit vertikaler Holztextur erzeugt. Die Kanten definieren einen Würfel mit Unit-Koordinaten. Dieser wird später skaliert. Beim Erzeugen der Grund- und Deckfläche wenden wir eine andere Textur an, nämlich eine dazu senkrechte Holztextur.
203	203
204	204		Zuletzt legen wir die Sichtbarkeit fest. Die soll ein bisschen von der Seite erfolgen. Der Standardwert ist (0,0,-100). Auf diese Weise hat die Szene etwas Perspektive.
205	205
206		-	~~<figure>~~
207		-	~~<img src="BGRATutorial16a.png" title="BGRATutorial16a.png" />~~
208		-	~~<figcaption>BGRATutorial16a.png</figcaption>~~
209		-	~~</figure>~~
	206	+	![](/wiki-images/c/c2/BGRATutorial16a.png)
210	207
211	208		### Beleuchtung und Normalen
212	209
213	210		Wir fügen einfach etwas Licht hinzu:
214	211
215	212		``` pascal
216	213		LightingNormal:= lnFace;
217	214
218	215		AmbiantLightness := 0.25;
219	216		with CreateObject do
220	217		begin
221	218		AddPointLight(MainPart.Add(-100,-80,0),140,0.5);
222	219		end;
223	220		```
224	221
225	222		Hier wird die Helligkeit genau so wie im letzten Tutorial verwendet. Aber die Lichtquelle ist punktförmig. Um eine Kante festzulegen brauchen wir ein Objekt, das diese beinhaltet. Es ist möglich, später das Licht zu verschieben. Je weiter ein Objekt vom Licht entfernt ist, desto dunkler ist es. Der Parameter der optimalen Distanz gibt die Distanz an, die Lichtintensität steht im nächsten Parameter. Das bedeutet, wenn ein Objekt in einer Distanz von 140 ist, dann ist die Helligkeit 0.5.
226	223
227	224		Beachten Sie: Wir haben LightingNormal zu lnFace festgelegt. Dies ergibt, dass das Licht so berechnet wird, als wären die Seitenflächen flach. Die Beleutung berücksichtigt keine Abrundungen. Die könnte in anderen Fällen nützlich sein, aber nicht hier.
228	225
229		-	~~<figure>~~
230		-	~~<img src="BGRATutorial16b.png" title="BGRATutorial16b.png" />~~
231		-	~~<figcaption>BGRATutorial16b.png</figcaption>~~
232		-	~~</figure>~~
	226	+	![](/wiki-images/3/3a/BGRATutorial16b.png)
233	227
234	228		[[BGRABitmap tutorial 15/de\|Voriges Tutorial (3D)]]
235	229
236	230		Seite übersetzt durch: --billyraybones 12:06, 23 October 2011 (CEST)
237	231
238	232		---
239	233		From the Free Pascal wiki, page "BGRABitmap tutorial 16/de", as it stood on 2020-02-10 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history