Navigation

← Previous Changeset
Next Changeset →

Changeset 198

Timestamp:

11/05/07 16:13:59 (1 year ago)

Author:

LeoD

Message:

Files:

branches/jobs/defend/Main.d (modified) (4 diffs)
branches/jobs/defend/com/Gateway.d (modified) (1 diff)
branches/jobs/defend/demo/Demo.d (modified) (2 diffs)
branches/jobs/defend/game/Game.d (modified) (7 diffs)
branches/jobs/defend/game/Mouse.d (modified) (5 diffs)
branches/jobs/defend/game/net/client/Client.d (modified) (1 diff)
branches/jobs/defend/menu/Menu.d (modified) (1 diff)
branches/jobs/defend/terrain/Terrain.d (modified) (2 diffs)
branches/jobs/gen/core (added)
branches/jobs/gen/core/JobSystem.d (added)
branches/jobs/gen/list/Queue.d (modified) (5 diffs)
branches/jobs/gen/list/Sort.d (added)
branches/jobs/gen/list/TurboList.d (modified) (2 diffs)
branches/jobs/gen/renderer/Renderer.d (modified) (1 diff)
branches/jobs/gen/renderer/opengl/Renderer.d (modified) (1 diff)
branches/jobs/gen/util/Gamestates.d (modified) (3 diffs)
branches/jobs/gen/util/ScreenDebugger.d (modified) (4 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

branches/jobs/defend/Main.d

r188	r198
12	12	import Integer = tango.text.convert.Integer;
13	13
	14	import gen.core.JobSystem;
14	15	import gen.util.Gamestates;
15	16	import gen.util.Wrapper;
…	…
77	78	loadConfig();
78	79
	80	// Create job system
	81	jobSystem = new JobSystem();
	82
79	83	// Create the renderer
80	84	logger.info("creating renderer");
…	…
126	130	frameBegin = getTickCount();
127	131
128		bool continueLoop = false;
129		profile!("update")
130		({
131		gamestateManager.update(frameTime);
132
133		if(gamestateManager.exit)
134		continueLoop = true;
135
136		inputManager.update();
137		});
138
139		if(continueLoop)
140		return;
141
142		profile!("render")
143		({
144		renderer.begin();
145
146		// Only render, when the window is active
147		if(renderer.window.active)
148		{
149		gamestateManager.render();
150
151		profile!("flip")
152		({
153		renderer.end();
154		});
155
156		profile!("clear")
157		({
158		renderer.clear();
159		});
160		}
161		});
162
	132	gamestateManager.run(frameTime);
	133
163	134	debug
164	135	{
…	…
175	146	// Limit FPS and calculate frame time
176	147	frameTime = getTickCount() - frameBegin;
177		while((frameTime = getTickCount() - frameBegin) < 10) sleep(1);
	148	//while((frameTime = getTickCount() - frameBegin) < 10) sleep(1);
178	149	});
179	150	});
180	151	}
181	152
	153	jobSystem.shutdown();
	154
182	155	logger.info("program execution finished normally");
183	156	return 0;

branches/jobs/defend/com/Gateway.d

r181	r198
30	30	void update();
31	31
32		// Tell the gateway that you're ready to start teh game
	32	// Tell the gateway that you're ready to start the game
33	33	void ready();
34	34

branches/jobs/defend/demo/Demo.d

r188	r198
19	19	import defend.terrain.Terrain;
20	20
21		class Demo : IGameState
	21	/*class Demo : IGameState
22	22	{
23	23	private:
…	…
84	84	sceneGraph.clear();
85	85	}
86		}
	86	}*/

branches/jobs/defend/game/Game.d

r194	r198
9	9	import Integer = tango.text.convert.Integer;
10	10
	11	import gen.core.JobSystem;
11	12	import gen.util.Wrapper;
12	13	import gen.util.Profiler;
…	…
87	88	Sprite2D miniScreenSprite;
88	89
	90	// Frame time
	91	float frameTime;
	92	bool doRender = false;
	93
89	94	// Demo recorder
90	95	DemoRecorder demoRecorder;
…	…
218	223	miniScreenActivated = false;
219	224	}
	225
	226	// Create jobs
	227	void jobUpdateSyncs()
	228	{
	229	syncs.update(frameTime);
	230	}
	231
	232	void jobUpdateHUD()
	233	{
	234	hud.update(frameTime);
	235	}
	236
	237	void jobUpdateGraph()
	238	{
	239	sceneGraph.update(frameTime);
	240	}
	241
	242	void jobInput()
	243	{
	244	inputManager.update();
	245
	246	if(inputManager.keyPressed(KeyType.L))
	247	wireframe = !wireframe;
	248
	249	if(inputManager.keyPressedFirst(KeyType.G))
	250	sceneGraph.debugVisible = !sceneGraph.debugVisible;
	251
	252	if(inputManager.keyPressedFirst(KeyType.C))
	253	{
	254	Stdout("GC collect!").newline;
	255	GC.collect();
	256	}
	257
	258	if(inputManager.keyPressedFirst(KeyType.M))
	259	toggleMiniScreen();
	260	}
	261
	262	void jobRender()
	263	{
	264	doRender = true;
	265	}
	266
	267	void createJobs()
	268	{
	269	auto inputJob = jobSystem.addFrameJob("input", &jobInput);
	270
	271	auto simulationJob = jobSystem.addFrameJob("simulation", &gateway.runSimulation);
	272	auto gatewayJob = jobSystem.addFrameJob("gateway", &gateway.update);
	273	auto updateSyncsJob = jobSystem.addFrameJob("syncs", &jobUpdateSyncs);
	274	//updateSyncsJob.dependOn(simulationJob);
	275
	276	auto hudJob = jobSystem.addFrameJob("hud", &jobUpdateHUD);
	277	hudJob.dependOn(inputJob);
	278
	279	auto mouseJob = jobSystem.addFrameJob("mouse", &mouse.update);
	280	mouseJob.dependOn(inputJob);
	281
	282	auto updateGraphJob = jobSystem.addFrameJob("graph", &jobUpdateGraph);
	283	updateGraphJob.dependOn(updateSyncsJob);
	284
	285	auto renderJob = jobSystem.addFrameJob("render", &jobRender);
	286	renderJob.dependOn(hudJob);
	287	renderJob.dependOn(updateSyncsJob);
	288	renderJob.dependOn(simulationJob);
	289	renderJob.dependOn(gatewayJob);
	290	renderJob.dependOn(updateGraphJob);
	291	renderJob.dependOn(mouseJob);
	292	}
220	293
221	294	public:
…	…
256	329	mouse = new Mouse(syncs);
257	330	hud = new HUD(syncs);
258
259		~~// Fogging~~
260		~~//renderer.setRenderState(RenderState.Fog, true);~~
261		~~//renderer.setFog(FogMode.Linear, 1, 50, 90, Vec3f(0));~~
262
263		~~// Skybox~~
264		~~//sceneGraph.addNode(new Skybox("data/skyboxes/FR.jpg", "data/skyboxes/LF.jpg", "data/skyboxes/BK.jpg",~~
265		~~// "data/skyboxes/RT.jpg", "data/skyboxes/UP.jpg", "data/skyboxes/DN.jpg"));~~
266	331
267	332	// Initialize the map
…	…
280	345	if(gateway.id == 0)
281	346	{
282		~~//for(uint i = 0; i < 20; i++)~~
283		~~// gateway.createObject(ObjectType.Box, ObjectPos(random!(object_pos_t)(10, map.size.x - 10),~~
284		~~// random!(object_pos_t)(10, map.size.y - 10)));~~
285
286	347	gateway.createObject(ObjectType.House, ObjectPos(32, 30));
287		~~//gateway.createObject(ObjectType.House, ObjectPos(20, 25));~~
288	348	gateway.createObject(ObjectType.House, ObjectPos(37, 30));
289	349	}
…	…
291	351	logger.info("graphics card memory usage is " ~ Integer.toUtf8(renderer.memoryUsage) ~ " bytes (" ~
292	352	Integer.toUtf8(renderer.memoryUsage / 1024) ~ "kb)");
	353
	354	createJobs();
293	355
294	356	GC.collect();
…	…
321	383	}
322	384
323		override void update(float time)
324		{
325		syncs.update(time);
326
327		profile!("scene graph", "update")
328		({
329		sceneGraph.update(time);
330		});
331
332		if(inputManager.keyPressedFirst(KeyType.L))
333		wireframe = !wireframe;
334
335		if(inputManager.keyPressedFirst(KeyType.G))
336		sceneGraph.debugVisible = !sceneGraph.debugVisible;
337
338		if(inputManager.keyPressedFirst(KeyType.C))
	385	override void run(float time)
	386	{
	387	frameTime = time;
	388	doRender = false;
	389
	390	jobSystem.startFrame();
	391
	392	while(!doRender)
	393	sleep(1);
	394
	395	if(renderer.window.active)
339	396	{
340		Stdout("GC collect!").newline;
341		GC.collect();
	397	renderer.update();
	398	renderer.begin();
	399
	400	// First the 3D objects
	401	if(wireframe) renderer.setRenderState(RenderState.Wireframe, true);
	402
	403	profile!("scene graph", "render")
	404	({
	405	sceneGraph.draw();
	406	});
	407
	408	renderer.setMatrix(mainCamera.modelview, MatrixType.Modelview);
	409	renderer.setMatrix(mainCamera.projection, MatrixType.Projection);
	410	syncs.render();
	411
	412	if(wireframe) renderer.setRenderState(RenderState.Wireframe, false);
	413
	414	// And then the 2D objects
	415	profile!("hud", "render")
	416	({
	417	renderer.setRenderState(RenderState.DepthTest, false);
	418	renderer.orthogonal();
	419	renderer.identity();
	420	hud.render();
	421
	422	if(miniScreenActivated)
	423	miniScreenSprite.render(Vec2ui(renderer.width - miniScreenSprite.rect.width, 0));
	424
	425	mouse.render();
	426
	427	renderer.setRenderState(RenderState.DepthTest, true);
	428	});
	429
	430	renderer.end();
	431	renderer.clear();
342	432	}
343
344		if(inputManager.keyPressedFirst(KeyType.M))
345		toggleMiniScreen();
346
347		profile!("gateway")
348		({
349		gateway.update();
350		});
351
352		if(gatewayShutdown)
353		return;
354
355		profile!("hud", "update")
356		({
357		hud.update(time);
358		mouse.update();
359		});
360		}
361
362		override void render()
363		{
364		// First the 3D objects
365		if(wireframe) renderer.setRenderState(RenderState.Wireframe, true);
366
367		profile!("scene graph", "render")
368		({
369		sceneGraph.draw();
370		});
371
372		renderer.setMatrix(mainCamera.modelview, MatrixType.Modelview);
373		renderer.setMatrix(mainCamera.projection, MatrixType.Projection);
374		syncs.render();
375
376		if(wireframe) renderer.setRenderState(RenderState.Wireframe, false);
377
378		// And then the 2D objects
379		profile!("hud", "render")
380		({
381		renderer.setRenderState(RenderState.DepthTest, false);
382		renderer.orthogonal();
383		renderer.identity();
384		hud.render();
385
386		if(miniScreenActivated)
387		miniScreenSprite.render(Vec2ui(renderer.width - miniScreenSprite.rect.width, 0));
388
389		mouse.render();
390
391		renderer.setRenderState(RenderState.DepthTest, true);
392		});
	433
	434	jobSystem.endFrame();
393	435	}
394	436	}

branches/jobs/defend/game/Mouse.d

r194	r198
67	67	auto projection = camera.projection().convert!(double);
68	68
69		glGetIntegerv(GL_VIEWPORT, viewport.ptr);
70
	69	//glGetIntegerv(GL_VIEWPORT, viewport.ptr);
	70	viewport[2] = renderer.width;
	71	viewport[3] = renderer.height;
	72
71	73	Vec3d result;
72	74	gluProject(pos.x, pos.y, pos.z, modelview.ptr, projection.ptr, viewport.ptr, &result.x, &result.y, &result.z);
…	…
83	85	auto projection = camera.projection().convert!(double);
84	86
85		glGetIntegerv(GL_VIEWPORT, viewport.ptr);
	87	//glGetIntegerv(GL_VIEWPORT, viewport.ptr);
	88	viewport[2] = renderer.width;
	89	viewport[3] = renderer.height;
86	90
87	91	pt.y = viewport[3] - pt.y;
…	…
249	253	inputManager.mousePosition.x > renderer.width \|\| inputManager.mousePosition.y > renderer.height)
250	254	return;
251
252		_ray = calcRay();
	255
253	256	calcTilePos();
254	257
…	…
266	269	if(mousePos.y < renderer.height - HUD_HEIGHT \|\| areaSelection)
267	270	{
268		if(inputManager.keyPressed~~First~~(KeyType.LeftButton) && !areaSelection)
	271	if(inputManager.keyPressed(KeyType.LeftButton) && !areaSelection)
269	272	{
270	273	if(!inputManager.keyPressed(KeyType.LeftControl) \|\|
…	…
409	412	void render()
410	413	{
	414	_ray = calcRay();
	415
411	416	auto mousePos = inputManager.mousePosition;
412	417

branches/jobs/defend/game/net/client/Client.d

r186	r198
372	372	screenDebugger.write("current phase: {}", phase);
373	373
374		~~runSimulation();~~
375	374	processMessages();
376	375	}

branches/jobs/defend/menu/Menu.d

r188	r198
68	68	}
69	69
70		override void ~~update(float time~~)
	70	override void run(float)
71	71	{
72
73		}
74
75		override void render()
76		{
77
	72
78	73	}
79	74	}

branches/jobs/defend/terrain/Terrain.d

r194	r198
232	232	}
233	233
234		void createCullTree()
235		{
236		TerrainPatch getPatch(uint x, uint y)
237		{
	234	void createCullTree()
	235	{
	236	TerrainPatch getPatch(uint x, uint y)
	237	{
238	238	return patches[x * patchCount + y];
239		}
240
241		void areaPatches(Rect area, void delegate(TerrainPatch) dg)
242		{
	239	}
	240
	241	void areaPatches(Rect area, void delegate(TerrainPatch) dg)
	242	{
243	243	for(uint x = area.left; x < area.right; x++)
244	244	{
…	…
248	248	}
249	249	}
250		}
251
252		void delegate(Rect, SceneNode) forwardCreatePart;
253
254		void callSub(Rect area, SceneNode parent)
255		{
256		uint numChilds = 2;
257		uint partRight = area.left + area.width / numChilds;
258		uint partBottom = area.top + area.height / numChilds;
259
260		forwardCreatePart(Rect(area.left, area.top, partRight, partBottom), parent);
	250	}
	251
	252	void delegate(Rect, SceneNode) forwardCreatePart;
	253
	254	void callSub(Rect area, SceneNode parent)
	255	{
	256	uint numChilds = 2;
	257	uint partRight = area.left + area.width / numChilds;
	258	uint partBottom = area.top + area.height / numChilds;
	259
	260	forwardCreatePart(Rect(area.left, area.top, partRight, partBottom), parent);
261	261	forwardCreatePart(Rect(area.left, partBottom, partRight, area.bottom), parent);
262		forwardCreatePart(Rect(partRight, area.top, area.right, partBottom), parent);
263		forwardCreatePart(Rect(partRight, partBottom, area.right, area.bottom), parent);
264		}
265
266		void createPart(Rect area, SceneNode parent)
267		{
268		// If this area is only containing one patch, we're at the bottom of the hierarchy
269		if(area.width == 1 && area.height == 1)
270		{
271		areaPatches(area, (TerrainPatch patch)
272		{
	262	forwardCreatePart(Rect(partRight, area.top, area.right, partBottom), parent);
	263	forwardCreatePart(Rect(partRight, partBottom, area.right, area.bottom), parent);
	264	}
	265
	266	void createPart(Rect area, SceneNode parent)
	267	{
	268	// If this area is only containing one patch, we're at the bottom of the hierarchy
	269	if(area.width == 1 && area.height == 1)
	270	{
	271	areaPatches(area, (TerrainPatch patch)
	272	{
273	273	parent.addChild(patch);
274		});
275
276		return;
277		}
278
279		// Create a bounding box surrounding all the patches in this area
280		auto cullNode = new CullNode;
281
282		areaPatches(area, (TerrainPatch patch)
283		{
284		cullNode.boundingBox.addPoint(patch.bbox.min);
285		cullNode.boundingBox.addPoint(patch.bbox.max);
286		});
287
288		parent.addChild(cullNode);
289
290		// Split the area into 4 parts and recurse
	274	});
	275
	276	return;
	277	}
	278
	279	// Create a bounding box surrounding all the patches in this area
	280	auto cullNode = new CullNode;
	281
	282	areaPatches(area, (TerrainPatch patch)
	283	{
	284	cullNode.boundingBox.addPoint(patch.bbox.min);
	285	cullNode.boundingBox.addPoint(patch.bbox.max);
	286	});
	287
	288	parent.addChild(cullNode);
	289
	290	// Split the area into 4 parts and recurse
291	291	callSub(area, cullNode);
292		}
293
294		forwardCreatePart = &createPart;
295		callSub(Rect(0, 0, patchCount, patchCount), this);
296		}
	292	}
	293
	294	forwardCreatePart = &createPart;
	295	callSub(Rect(0, 0, patchCount, patchCount), this);
	296	}
297	297
298	298	public:

branches/jobs/gen/list/Queue.d

r194	r198
22	22	{
23	23	if(i == writePosition)
24		Stdout("!")();
	24	synchronized(Stdout) Stdout("!")();
25	25
26	26	if(i == readPosition)
27		Stdout("?")();
	27	synchronized(Stdout) Stdout("?")();
28	28
29		Stdout(element)(" ")();
	29	synchronized(Stdout) Stdout(element)(" ")();
30	30	}
31	31
32		Stdout.newline;
	32	synchronized(Stdout) Stdout.newline;
33	33	}
34	34
…	…
56	56	debug(queue)
57	57	{
58		Stdout("enlarging at ")(position).newline;
	58	synchronized(Stdout) Stdout("enlarging at ")(position).newline;
59	59	debugQueue();
60	60	}
…	…
69	69	debug(queue)
70	70	{
71		Stdout.newline;
	71	synchronized(Stdout) Stdout.newline;
72	72	debugQueue();
73	73	}
74	74
75		Stdout.newline;
76		Stdout(" ------------------ ENLARGE!!!!!!!!!!!!!").newline;
77		Stdout.newline;
	75	debug(queue) synchronized(Stdout)
	76	{
	77	Stdout.newline;
	78	Stdout(" ------------------ ENLARGE!!!!!!!!!!!!!").newline;
	79	Stdout.newline;
	80	}
78	81
79	82	readPosition++;
…	…
88	91	debug(queue)
89	92	{
90		Stdout("PUSHing ")(element)(" at ")(position).newline;
	93	synchronized(Stdout) Stdout("PUSHing ")(element)(" at ")(position).newline;
91	94	debugQueue(); Stdout.newline;
92	95	}
…	…
104	107	debug(queue)
105	108	{
106		Stdout("POPping ")(elements[readPosition])(" at ")(readPosition).newline;
	109	synchronized(Stdout) Stdout("POPping ")(elements[readPosition])(" at ")(readPosition).newline;
107	110	debugQueue(); Stdout.newline;
108	111	}

branches/jobs/gen/list/TurboList.d

r184	r198
6	6	import gen.util.Swap;
7	7	import gen.util.Array;
	8	import gen.list.Sort;
8	9
9	10	class TurboList(T)
…	…
174	175	void sort(int delegate(T, T) c)
175	176	{
176		void quicksort(int l, int r)
177		{
178		int i = l;
179		int j = r;
180		T x = buffer[(l + r) / 2];
181
182		while(i <= j)
183		{
184		while(c(buffer[i], x) < 0)
185		i++;
186
187		while(c(buffer[j], x) > 0)
188		j--;
189
190		if(i <= j)
191		{
192		swap(buffer[i], buffer[j]);
193
194		i++;
195		j--;
196		}
197		}
198
199		if(l < j)
200		quicksort(l, j);
201
202		if(i < r)
203		quicksort(i, r);
204		}
205
206		if(top == 0)
207		return;
208
209		quicksort(0, top - 1);
	177	quicksort(toArray(), c);
210	178	}
211	179

branches/jobs/gen/renderer/Renderer.d

r193	r198
148	148
149	149	/**
150		* Start rendering.
	150	* Update
	151	*/
	152	void update();
	153
	154	/**
	155	* Start rendering
151	156	*/
152	157	void begin();

branches/jobs/gen/renderer/opengl/Renderer.d

r193	r198
306	306	}
307	307
	308	override void update()
	309	{
	310	_window.update();
	311	}
	312
308	313	override void begin()
309	314	{
310		~~_window.update();~~
	315
311	316	}
312	317

branches/jobs/gen/util/Gamestates.d

r67	r198
18	18	void init();
19	19	void done();
20		void update(float time);
21		void render();
	20	void run(float time);
22	21	}
23	22
…	…
61	60	assert(g !is null);
62	61	}
63		~~out~~
64		{
65		~~//assert(gamestate is g);~~
66		}
67	62	body
68	63	{
…	…
93	88	}
94	89
95		void ~~update~~(float time)
	90	void run(float time)
96	91	in
97	92	{
98		assert(gamestate !is null);
	93	assert(gamestate !is null);
99	94	}
100	95	body
101	96	{
102		gamestate.update(time);
103		}
104
105		void render()
106		in
107		{
108		assert(gamestate !is null);
109		}
110		body
111		{
112		gamestate.render();
	97	gamestate.run(time);
113	98	}
114	99	}

branches/jobs/gen/util/ScreenDebugger.d

r187	r198
1	1	module gen.util.ScreenDebugger;
2	2
	3	import tango.io.Stdout;
3	4	import tango.text.convert.Layout;
4	5
	6	import gen.font.Font;
	7	import gen.list.TurboList;
5	8	import gen.util.Singleton;
6		import gen.~~font.Font~~;
	9	import gen.renderer.Renderer;
7	10	import gen.math.Vector;
8		~~import gen.renderer.Renderer;~~
9	11	import gen.math.Random;
10	12
…	…
21	23	}
22	24
23		Line[64] lines;
	25	Line*[64] lines;
24	26	uint currentLine;
	27
	28	TurboList!(Line*) sortList;
25	29
26	30	public:
…	…
33	37	foreach(i, ref l; lines)
34	38	{
	39	l = new Line;
35	40	l.text = new char[512];
36	41	l.color = (i % 2 == 0) ? Vec3f(1) : Vec3f(0.8);
37	42	}
	43
	44	sortList = new typeof(sortList)(lines.length);
38	45	}
39	46
40		void write(char[] format, ...)
	47	synchronized void write(char[] format, ...)
41	48	{
42	49	if(!active \|\| !renderer.window.active \|\| currentLine >= lines.length - 1)
…	…
54	61	return;
55	62
56		foreach(~~i, ref~~ l; lines)
	63	foreach(l; lines)
57	64	{
58		if(l.length)
59		font.write(pos.x, pos.y + (font.maxHeight + 4) * i, l.color, l.text[0 .. l.length]);
60
61		l.length = 0;
	65	if(l.length)
	66	sortList.append(l);
62	67	}
63	68
	69	sortList.sort((Line* first, Line* second)
	70	{
	71	return typeid(char[]).compare(cast(void)&first.text, cast(void)&second.text);
	72	});
	73
	74	int i;
	75	foreach(l; sortList)
	76	{
	77	font.write(pos.x, pos.y + (font.maxHeight + 4) * i, l.color, l.text[0 .. l.length]);
	78
	79	l.length = 0;
	80	i++;
	81	}
	82
64	83	currentLine = 0;
	84	sortList.reset();
65	85	}
66	86

Navigation

Changeset 198

Legend:

Download in other formats: