quad-tex.c revision 3464ebd5 
1/**************************************************************************
2 *
3 * Copyright © 2010 Jakob Bornecrantz
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *
24 **************************************************************************/
25
26
27#define USE_TRACE 0
28#define WIDTH 300
29#define HEIGHT 300
30#define NEAR 30
31#define FAR 1000
32#define FLIP 0
33
34/* pipe_*_state structs */
35#include "pipe/p_state.h"
36/* pipe_context */
37#include "pipe/p_context.h"
38/* pipe_screen */
39#include "pipe/p_screen.h"
40/* PIPE_* */
41#include "pipe/p_defines.h"
42/* TGSI_SEMANTIC_{POSITION|GENERIC} */
43#include "pipe/p_shader_tokens.h"
44/* pipe_buffer_* helpers */
45#include "util/u_inlines.h"
46
47/* constant state object helper */
48#include "cso_cache/cso_context.h"
49
50/* u_sampler_view_default_template */
51#include "util/u_sampler.h"
52/* debug_dump_surface_bmp */
53#include "util/u_debug.h"
54/* util_draw_vertex_buffer helper */
55#include "util/u_draw_quad.h"
56/* FREE & CALLOC_STRUCT */
57#include "util/u_memory.h"
58/* util_make_[fragment|vertex]_passthrough_shader */
59#include "util/u_simple_shaders.h"
60
61/* sw_screen_create: to get a software pipe driver */
62#include "target-helpers/inline_sw_helper.h"
63/* debug_screen_wrap: to wrap with debug pipe drivers */
64#include "target-helpers/inline_debug_helper.h"
65/* null software winsys */
66#include "sw/null/null_sw_winsys.h"
67
68struct program
69{
70	struct pipe_screen *screen;
71	struct pipe_context *pipe;
72	struct cso_context *cso;
73
74	struct pipe_blend_state blend;
75	struct pipe_depth_stencil_alpha_state depthstencil;
76	struct pipe_rasterizer_state rasterizer;
77	struct pipe_sampler_state sampler;
78	struct pipe_viewport_state viewport;
79	struct pipe_framebuffer_state framebuffer;
80	struct pipe_vertex_element velem[2];
81
82	void *vs;
83	void *fs;
84
85	float clear_color[4];
86
87	struct pipe_resource *vbuf;
88	struct pipe_resource *target;
89	struct pipe_resource *tex;
90	struct pipe_sampler_view *view;
91};
92
93static void init_prog(struct program *p)
94{
95	struct pipe_surface surf_tmpl;
96	/* create the software rasterizer */
97	p->screen = sw_screen_create(null_sw_create());
98	/* wrap the screen with any debugger */
99	p->screen = debug_screen_wrap(p->screen);
100
101	/* create the pipe driver context and cso context */
102	p->pipe = p->screen->context_create(p->screen, NULL);
103	p->cso = cso_create_context(p->pipe);
104
105	/* set clear color */
106	p->clear_color[0] = 0.3;
107	p->clear_color[1] = 0.1;
108	p->clear_color[2] = 0.3;
109	p->clear_color[3] = 1.0;
110
111	/* vertex buffer */
112	{
113		float vertices[4][2][4] = {
114			{
115				{ 0.9f, 0.9f, 0.0f, 1.0f },
116				{ 1.0f, 1.0f, 0.0f, 1.0f }
117			},
118			{
119				{ -0.9f, 0.9f, 0.0f, 1.0f },
120				{  0.0f, 1.0f, 0.0f, 1.0f }
121			},
122			{
123				{ -0.9f, -0.9f, 0.0f, 1.0f },
124				{  0.0f,  0.0f, 1.0f, 1.0f }
125			},
126			{
127				{ 0.9f, -0.9f, 0.0f, 1.0f },
128				{ 1.0f,  0.0f, 1.0f, 1.0f }
129			}
130		};
131
132		p->vbuf = pipe_buffer_create(p->screen, PIPE_BIND_VERTEX_BUFFER,
133					     PIPE_USAGE_STATIC, sizeof(vertices));
134		pipe_buffer_write(p->pipe, p->vbuf, 0, sizeof(vertices), vertices);
135	}
136
137	/* render target texture */
138	{
139		struct pipe_resource tmplt;
140		memset(&tmplt, 0, sizeof(tmplt));
141		tmplt.target = PIPE_TEXTURE_2D;
142		tmplt.format = PIPE_FORMAT_B8G8R8A8_UNORM; /* All drivers support this */
143		tmplt.width0 = WIDTH;
144		tmplt.height0 = HEIGHT;
145		tmplt.depth0 = 1;
146		tmplt.array_size = 1;
147		tmplt.last_level = 0;
148		tmplt.bind = PIPE_BIND_RENDER_TARGET;
149
150		p->target = p->screen->resource_create(p->screen, &tmplt);
151	}
152
153	/* sampler texture */
154	{
155		uint32_t *ptr;
156		struct pipe_transfer *t;
157		struct pipe_resource t_tmplt;
158		struct pipe_sampler_view v_tmplt;
159		struct pipe_box box;
160
161		memset(&t_tmplt, 0, sizeof(t_tmplt));
162		t_tmplt.target = PIPE_TEXTURE_2D;
163		t_tmplt.format = PIPE_FORMAT_B8G8R8A8_UNORM; /* All drivers support this */
164		t_tmplt.width0 = 2;
165		t_tmplt.height0 = 2;
166		t_tmplt.depth0 = 1;
167		t_tmplt.array_size = 1;
168		t_tmplt.last_level = 0;
169		t_tmplt.bind = PIPE_BIND_RENDER_TARGET;
170
171		p->tex = p->screen->resource_create(p->screen, &t_tmplt);
172
173		memset(&box, 0, sizeof(box));
174		box.width = 2;
175		box.height = 2;
176
177		t = p->pipe->get_transfer(p->pipe, p->tex, 0, PIPE_TRANSFER_WRITE, &box);
178
179		ptr = p->pipe->transfer_map(p->pipe, t);
180		ptr[0] = 0xffff0000;
181		ptr[1] = 0xff0000ff;
182		ptr[2] = 0xff00ff00;
183		ptr[3] = 0xffffff00;
184		p->pipe->transfer_unmap(p->pipe, t);
185
186		p->pipe->transfer_destroy(p->pipe, t);
187
188		u_sampler_view_default_template(&v_tmplt, p->tex, p->tex->format);
189
190		p->view = p->pipe->create_sampler_view(p->pipe, p->tex, &v_tmplt);
191	}
192
193	/* disabled blending/masking */
194	memset(&p->blend, 0, sizeof(p->blend));
195	p->blend.rt[0].colormask = PIPE_MASK_RGBA;
196
197	/* no-op depth/stencil/alpha */
198	memset(&p->depthstencil, 0, sizeof(p->depthstencil));
199
200	/* rasterizer */
201	memset(&p->rasterizer, 0, sizeof(p->rasterizer));
202	p->rasterizer.cull_face = PIPE_FACE_NONE;
203	p->rasterizer.gl_rasterization_rules = 1;
204
205	/* sampler */
206	memset(&p->sampler, 0, sizeof(p->sampler));
207	p->sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
208	p->sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
209	p->sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
210	p->sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
211	p->sampler.min_img_filter = PIPE_TEX_MIPFILTER_LINEAR;
212	p->sampler.mag_img_filter = PIPE_TEX_MIPFILTER_LINEAR;
213	p->sampler.normalized_coords = 1;
214
215	surf_tmpl.format = PIPE_FORMAT_B8G8R8A8_UNORM; /* All drivers support this */
216	surf_tmpl.usage = PIPE_BIND_RENDER_TARGET;
217	surf_tmpl.u.tex.level = 0;
218	surf_tmpl.u.tex.first_layer = 0;
219	surf_tmpl.u.tex.last_layer = 0;
220	/* drawing destination */
221	memset(&p->framebuffer, 0, sizeof(p->framebuffer));
222	p->framebuffer.width = WIDTH;
223	p->framebuffer.height = HEIGHT;
224	p->framebuffer.nr_cbufs = 1;
225	p->framebuffer.cbufs[0] = p->pipe->create_surface(p->pipe, p->target, &surf_tmpl);
226
227	/* viewport, depth isn't really needed */
228	{
229		float x = 0;
230		float y = 0;
231		float z = FAR;
232		float half_width = (float)WIDTH / 2.0f;
233		float half_height = (float)HEIGHT / 2.0f;
234		float half_depth = ((float)FAR - (float)NEAR) / 2.0f;
235		float scale, bias;
236
237		if (FLIP) {
238			scale = -1.0f;
239			bias = (float)HEIGHT;
240		} else {
241			scale = 1.0f;
242			bias = 0.0f;
243		}
244
245		p->viewport.scale[0] = half_width;
246		p->viewport.scale[1] = half_height * scale;
247		p->viewport.scale[2] = half_depth;
248		p->viewport.scale[3] = 1.0f;
249
250		p->viewport.translate[0] = half_width + x;
251		p->viewport.translate[1] = (half_height + y) * scale + bias;
252		p->viewport.translate[2] = half_depth + z;
253		p->viewport.translate[3] = 0.0f;
254	}
255
256	/* vertex elements state */
257	memset(p->velem, 0, sizeof(p->velem));
258	p->velem[0].src_offset = 0 * 4 * sizeof(float); /* offset 0, first element */
259	p->velem[0].instance_divisor = 0;
260	p->velem[0].vertex_buffer_index = 0;
261	p->velem[0].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
262
263	p->velem[1].src_offset = 1 * 4 * sizeof(float); /* offset 16, second element */
264	p->velem[1].instance_divisor = 0;
265	p->velem[1].vertex_buffer_index = 0;
266	p->velem[1].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
267
268	/* vertex shader */
269	{
270		const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,
271		                                TGSI_SEMANTIC_GENERIC };
272		const uint semantic_indexes[] = { 0, 0 };
273		p->vs = util_make_vertex_passthrough_shader(p->pipe, 2, semantic_names, semantic_indexes);
274	}
275
276	/* fragment shader */
277	p->fs = util_make_fragment_tex_shader(p->pipe, TGSI_TEXTURE_2D, TGSI_INTERPOLATE_LINEAR);
278}
279
280static void close_prog(struct program *p)
281{
282	/* unset bound textures as well */
283	cso_set_fragment_sampler_views(p->cso, 0, NULL);
284
285	/* unset all state */
286	cso_release_all(p->cso);
287
288	p->pipe->delete_vs_state(p->pipe, p->vs);
289	p->pipe->delete_fs_state(p->pipe, p->fs);
290
291	pipe_surface_reference(&p->framebuffer.cbufs[0], NULL);
292	pipe_sampler_view_reference(&p->view, NULL);
293	pipe_resource_reference(&p->target, NULL);
294	pipe_resource_reference(&p->tex, NULL);
295	pipe_resource_reference(&p->vbuf, NULL);
296
297	cso_destroy_context(p->cso);
298	p->pipe->destroy(p->pipe);
299	p->screen->destroy(p->screen);
300
301	FREE(p);
302}
303
304static void draw(struct program *p)
305{
306	/* set the render target */
307	cso_set_framebuffer(p->cso, &p->framebuffer);
308
309	/* clear the render target */
310	p->pipe->clear(p->pipe, PIPE_CLEAR_COLOR, p->clear_color, 0, 0);
311
312	/* set misc state we care about */
313	cso_set_blend(p->cso, &p->blend);
314	cso_set_depth_stencil_alpha(p->cso, &p->depthstencil);
315	cso_set_rasterizer(p->cso, &p->rasterizer);
316	cso_set_viewport(p->cso, &p->viewport);
317
318	/* sampler */
319	cso_single_sampler(p->cso, 0, &p->sampler);
320	cso_single_sampler_done(p->cso);
321
322	/* texture sampler view */
323	cso_set_fragment_sampler_views(p->cso, 1, &p->view);
324
325	/* shaders */
326	cso_set_fragment_shader_handle(p->cso, p->fs);
327	cso_set_vertex_shader_handle(p->cso, p->vs);
328
329	/* vertex element data */
330	cso_set_vertex_elements(p->cso, 2, p->velem);
331
332	util_draw_vertex_buffer(p->pipe, p->cso,
333	                        p->vbuf, 0,
334	                        PIPE_PRIM_QUADS,
335	                        4,  /* verts */
336	                        2); /* attribs/vert */
337
338        p->pipe->flush(p->pipe, NULL);
339
340	debug_dump_surface_bmp(p->pipe, "result.bmp", p->framebuffer.cbufs[0]);
341}
342
343int main(int argc, char** argv)
344{
345	struct program *p = CALLOC_STRUCT(program);
346
347	init_prog(p);
348	draw(p);
349	close_prog(p);
350
351	return 0;
352}
353