1/*
2 * Copyright 2009 Joakim Sindholt <opensource@zhasha.com>
3 *                Corbin Simpson <MostAwesomeDude@gmail.com>
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 * on the rights to use, copy, modify, merge, publish, distribute, sub
9 * license, and/or sell copies of the Software, and to permit persons to whom
10 * the 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 NON-INFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
20 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
21 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
22 * USE OR OTHER DEALINGS IN THE SOFTWARE. */
23
24#ifndef R300_STATE_INLINES_H
25#define R300_STATE_INLINES_H
26
27#include "draw/draw_vertex.h"
28#include "pipe/p_format.h"
29#include "util/u_format.h"
30#include "r300_reg.h"
31#include <stdio.h>
32
33/* Some maths. These should probably find their way to u_math, if needed. */
34
35static INLINE int pack_float_16_6x(float f) {
36    return ((int)(f * 6.0) & 0xffff);
37}
38
39/* Blend state. */
40
41static INLINE uint32_t r300_translate_blend_function(int blend_func,
42                                                     boolean clamp)
43{
44    switch (blend_func) {
45    case PIPE_BLEND_ADD:
46        return clamp ? R300_COMB_FCN_ADD_CLAMP : R300_COMB_FCN_ADD_NOCLAMP;
47    case PIPE_BLEND_SUBTRACT:
48        return clamp ? R300_COMB_FCN_SUB_CLAMP : R300_COMB_FCN_SUB_NOCLAMP;
49    case PIPE_BLEND_REVERSE_SUBTRACT:
50        return clamp ? R300_COMB_FCN_RSUB_CLAMP : R300_COMB_FCN_RSUB_NOCLAMP;
51    case PIPE_BLEND_MIN:
52        return R300_COMB_FCN_MIN;
53    case PIPE_BLEND_MAX:
54        return R300_COMB_FCN_MAX;
55    default:
56        fprintf(stderr, "r300: Unknown blend function %d\n", blend_func);
57        assert(0);
58        break;
59    }
60    return 0;
61}
62
63/* XXX we can also offer the D3D versions of some of these... */
64static INLINE uint32_t r300_translate_blend_factor(int blend_fact)
65{
66    switch (blend_fact) {
67        case PIPE_BLENDFACTOR_ONE:
68            return R300_BLEND_GL_ONE;
69        case PIPE_BLENDFACTOR_SRC_COLOR:
70            return R300_BLEND_GL_SRC_COLOR;
71        case PIPE_BLENDFACTOR_SRC_ALPHA:
72            return R300_BLEND_GL_SRC_ALPHA;
73        case PIPE_BLENDFACTOR_DST_ALPHA:
74            return R300_BLEND_GL_DST_ALPHA;
75        case PIPE_BLENDFACTOR_DST_COLOR:
76            return R300_BLEND_GL_DST_COLOR;
77        case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
78            return R300_BLEND_GL_SRC_ALPHA_SATURATE;
79        case PIPE_BLENDFACTOR_CONST_COLOR:
80            return R300_BLEND_GL_CONST_COLOR;
81        case PIPE_BLENDFACTOR_CONST_ALPHA:
82            return R300_BLEND_GL_CONST_ALPHA;
83        case PIPE_BLENDFACTOR_ZERO:
84            return R300_BLEND_GL_ZERO;
85        case PIPE_BLENDFACTOR_INV_SRC_COLOR:
86            return R300_BLEND_GL_ONE_MINUS_SRC_COLOR;
87        case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
88            return R300_BLEND_GL_ONE_MINUS_SRC_ALPHA;
89        case PIPE_BLENDFACTOR_INV_DST_ALPHA:
90            return R300_BLEND_GL_ONE_MINUS_DST_ALPHA;
91        case PIPE_BLENDFACTOR_INV_DST_COLOR:
92            return R300_BLEND_GL_ONE_MINUS_DST_COLOR;
93        case PIPE_BLENDFACTOR_INV_CONST_COLOR:
94            return R300_BLEND_GL_ONE_MINUS_CONST_COLOR;
95        case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
96            return R300_BLEND_GL_ONE_MINUS_CONST_ALPHA;
97
98        case PIPE_BLENDFACTOR_SRC1_COLOR:
99        case PIPE_BLENDFACTOR_SRC1_ALPHA:
100        case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
101        case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
102            fprintf(stderr, "r300: Implementation error: "
103                "Bad blend factor %d not supported!\n", blend_fact);
104            assert(0);
105            break;
106
107        default:
108            fprintf(stderr, "r300: Unknown blend factor %d\n", blend_fact);
109            assert(0);
110            break;
111    }
112    return 0;
113}
114
115/* DSA state. */
116
117static INLINE uint32_t r300_translate_depth_stencil_function(int zs_func)
118{
119    switch (zs_func) {
120        case PIPE_FUNC_NEVER:
121            return R300_ZS_NEVER;
122        case PIPE_FUNC_LESS:
123            return R300_ZS_LESS;
124        case PIPE_FUNC_EQUAL:
125            return R300_ZS_EQUAL;
126        case PIPE_FUNC_LEQUAL:
127            return R300_ZS_LEQUAL;
128        case PIPE_FUNC_GREATER:
129            return R300_ZS_GREATER;
130        case PIPE_FUNC_NOTEQUAL:
131            return R300_ZS_NOTEQUAL;
132        case PIPE_FUNC_GEQUAL:
133            return R300_ZS_GEQUAL;
134        case PIPE_FUNC_ALWAYS:
135            return R300_ZS_ALWAYS;
136        default:
137            fprintf(stderr, "r300: Unknown depth/stencil function %d\n",
138                zs_func);
139            assert(0);
140            break;
141    }
142    return 0;
143}
144
145static INLINE uint32_t r300_translate_stencil_op(int s_op)
146{
147    switch (s_op) {
148        case PIPE_STENCIL_OP_KEEP:
149            return R300_ZS_KEEP;
150        case PIPE_STENCIL_OP_ZERO:
151            return R300_ZS_ZERO;
152        case PIPE_STENCIL_OP_REPLACE:
153            return R300_ZS_REPLACE;
154        case PIPE_STENCIL_OP_INCR:
155            return R300_ZS_INCR;
156        case PIPE_STENCIL_OP_DECR:
157            return R300_ZS_DECR;
158        case PIPE_STENCIL_OP_INCR_WRAP:
159            return R300_ZS_INCR_WRAP;
160        case PIPE_STENCIL_OP_DECR_WRAP:
161            return R300_ZS_DECR_WRAP;
162        case PIPE_STENCIL_OP_INVERT:
163            return R300_ZS_INVERT;
164        default:
165            fprintf(stderr, "r300: Unknown stencil op %d", s_op);
166            assert(0);
167            break;
168    }
169    return 0;
170}
171
172static INLINE uint32_t r300_translate_alpha_function(int alpha_func)
173{
174    switch (alpha_func) {
175        case PIPE_FUNC_NEVER:
176            return R300_FG_ALPHA_FUNC_NEVER;
177        case PIPE_FUNC_LESS:
178            return R300_FG_ALPHA_FUNC_LESS;
179        case PIPE_FUNC_EQUAL:
180            return R300_FG_ALPHA_FUNC_EQUAL;
181        case PIPE_FUNC_LEQUAL:
182            return R300_FG_ALPHA_FUNC_LE;
183        case PIPE_FUNC_GREATER:
184            return R300_FG_ALPHA_FUNC_GREATER;
185        case PIPE_FUNC_NOTEQUAL:
186            return R300_FG_ALPHA_FUNC_NOTEQUAL;
187        case PIPE_FUNC_GEQUAL:
188            return R300_FG_ALPHA_FUNC_GE;
189        case PIPE_FUNC_ALWAYS:
190            return R300_FG_ALPHA_FUNC_ALWAYS;
191        default:
192            fprintf(stderr, "r300: Unknown alpha function %d", alpha_func);
193            assert(0);
194            break;
195    }
196    return 0;
197}
198
199static INLINE uint32_t
200r300_translate_polygon_mode_front(unsigned mode) {
201    switch (mode)
202    {
203        case PIPE_POLYGON_MODE_FILL:
204            return R300_GA_POLY_MODE_FRONT_PTYPE_TRI;
205        case PIPE_POLYGON_MODE_LINE:
206            return R300_GA_POLY_MODE_FRONT_PTYPE_LINE;
207        case PIPE_POLYGON_MODE_POINT:
208            return R300_GA_POLY_MODE_FRONT_PTYPE_POINT;
209
210        default:
211            fprintf(stderr, "r300: Bad polygon mode %i in %s\n", mode,
212                __FUNCTION__);
213            return R300_GA_POLY_MODE_FRONT_PTYPE_TRI;
214    }
215}
216
217static INLINE uint32_t
218r300_translate_polygon_mode_back(unsigned mode) {
219    switch (mode)
220    {
221        case PIPE_POLYGON_MODE_FILL:
222            return R300_GA_POLY_MODE_BACK_PTYPE_TRI;
223        case PIPE_POLYGON_MODE_LINE:
224            return R300_GA_POLY_MODE_BACK_PTYPE_LINE;
225        case PIPE_POLYGON_MODE_POINT:
226            return R300_GA_POLY_MODE_BACK_PTYPE_POINT;
227
228        default:
229            fprintf(stderr, "r300: Bad polygon mode %i in %s\n", mode,
230                __FUNCTION__);
231            return R300_GA_POLY_MODE_BACK_PTYPE_TRI;
232    }
233}
234
235/* Texture sampler state. */
236
237static INLINE uint32_t r300_translate_wrap(int wrap)
238{
239    switch (wrap) {
240        case PIPE_TEX_WRAP_REPEAT:
241            return R300_TX_REPEAT;
242        case PIPE_TEX_WRAP_CLAMP:
243            return R300_TX_CLAMP;
244        case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
245            return R300_TX_CLAMP_TO_EDGE;
246        case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
247            return R300_TX_CLAMP_TO_BORDER;
248        case PIPE_TEX_WRAP_MIRROR_REPEAT:
249            return R300_TX_REPEAT | R300_TX_MIRRORED;
250        case PIPE_TEX_WRAP_MIRROR_CLAMP:
251            return R300_TX_CLAMP | R300_TX_MIRRORED;
252        case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
253            return R300_TX_CLAMP_TO_EDGE | R300_TX_MIRRORED;
254        case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
255            return R300_TX_CLAMP_TO_BORDER | R300_TX_MIRRORED;
256        default:
257            fprintf(stderr, "r300: Unknown texture wrap %d", wrap);
258            assert(0);
259            return 0;
260    }
261}
262
263static INLINE uint32_t r300_translate_tex_filters(int min, int mag, int mip,
264                                                  boolean is_anisotropic)
265{
266    uint32_t retval = 0;
267
268    switch (min) {
269    case PIPE_TEX_FILTER_NEAREST:
270        retval |= R300_TX_MIN_FILTER_NEAREST;
271        break;
272    case PIPE_TEX_FILTER_LINEAR:
273        retval |= is_anisotropic ? R300_TX_MIN_FILTER_ANISO :
274                                   R300_TX_MIN_FILTER_LINEAR;
275        break;
276    default:
277        fprintf(stderr, "r300: Unknown texture filter %d\n", min);
278        assert(0);
279    }
280
281    switch (mag) {
282    case PIPE_TEX_FILTER_NEAREST:
283        retval |= R300_TX_MAG_FILTER_NEAREST;
284        break;
285    case PIPE_TEX_FILTER_LINEAR:
286        retval |= is_anisotropic ? R300_TX_MAG_FILTER_ANISO :
287                                   R300_TX_MAG_FILTER_LINEAR;
288        break;
289    default:
290        fprintf(stderr, "r300: Unknown texture filter %d\n", mag);
291        assert(0);
292    }
293
294    switch (mip) {
295    case PIPE_TEX_MIPFILTER_NONE:
296        retval |= R300_TX_MIN_FILTER_MIP_NONE;
297        break;
298    case PIPE_TEX_MIPFILTER_NEAREST:
299        retval |= R300_TX_MIN_FILTER_MIP_NEAREST;
300        break;
301    case PIPE_TEX_MIPFILTER_LINEAR:
302        retval |= R300_TX_MIN_FILTER_MIP_LINEAR;
303        break;
304    default:
305        fprintf(stderr, "r300: Unknown texture filter %d\n", mip);
306        assert(0);
307    }
308
309    return retval;
310}
311
312static INLINE uint32_t r300_anisotropy(unsigned max_aniso)
313{
314    if (max_aniso >= 16) {
315        return R300_TX_MAX_ANISO_16_TO_1;
316    } else if (max_aniso >= 8) {
317        return R300_TX_MAX_ANISO_8_TO_1;
318    } else if (max_aniso >= 4) {
319        return R300_TX_MAX_ANISO_4_TO_1;
320    } else if (max_aniso >= 2) {
321        return R300_TX_MAX_ANISO_2_TO_1;
322    } else {
323        return R300_TX_MAX_ANISO_1_TO_1;
324    }
325}
326
327static INLINE uint32_t r500_anisotropy(unsigned max_aniso)
328{
329    if (!max_aniso) {
330        return 0;
331    }
332    max_aniso -= 1;
333
334    // Map the range [0, 15] to [0, 63].
335    return R500_TX_MAX_ANISO(MIN2((unsigned)(max_aniso*4.2001), 63)) |
336           R500_TX_ANISO_HIGH_QUALITY;
337}
338
339/* Translate pipe_formats into PSC vertex types. */
340static INLINE uint16_t
341r300_translate_vertex_data_type(enum pipe_format format) {
342    uint32_t result = 0;
343    const struct util_format_description *desc;
344    unsigned i;
345
346    desc = util_format_description(format);
347
348    if (desc->layout != UTIL_FORMAT_LAYOUT_PLAIN) {
349        return R300_INVALID_FORMAT;
350    }
351
352    /* Find the first non-VOID channel. */
353    for (i = 0; i < 4; i++) {
354        if (desc->channel[i].type != UTIL_FORMAT_TYPE_VOID) {
355            break;
356        }
357    }
358
359    switch (desc->channel[i].type) {
360        /* Half-floats, floats, doubles */
361        case UTIL_FORMAT_TYPE_FLOAT:
362            switch (desc->channel[i].size) {
363                case 16:
364                    /* Supported only on RV350 and later. */
365                    if (desc->nr_channels > 2) {
366                        result = R300_DATA_TYPE_FLT16_4;
367                    } else {
368                        result = R300_DATA_TYPE_FLT16_2;
369                    }
370                    break;
371                case 32:
372                    result = R300_DATA_TYPE_FLOAT_1 + (desc->nr_channels - 1);
373                    break;
374                default:
375                    return R300_INVALID_FORMAT;
376            }
377            break;
378        /* Unsigned ints */
379        case UTIL_FORMAT_TYPE_UNSIGNED:
380        /* Signed ints */
381        case UTIL_FORMAT_TYPE_SIGNED:
382            switch (desc->channel[i].size) {
383                case 8:
384                    result = R300_DATA_TYPE_BYTE;
385                    break;
386                case 16:
387                    if (desc->nr_channels > 2) {
388                        result = R300_DATA_TYPE_SHORT_4;
389                    } else {
390                        result = R300_DATA_TYPE_SHORT_2;
391                    }
392                    break;
393                default:
394                    return R300_INVALID_FORMAT;
395            }
396            break;
397        default:
398            return R300_INVALID_FORMAT;
399    }
400
401    if (desc->channel[i].type == UTIL_FORMAT_TYPE_SIGNED) {
402        result |= R300_SIGNED;
403    }
404    if (desc->channel[i].normalized) {
405        result |= R300_NORMALIZE;
406    }
407
408    return result;
409}
410
411static INLINE uint16_t
412r300_translate_vertex_data_swizzle(enum pipe_format format) {
413    const struct util_format_description *desc = util_format_description(format);
414    unsigned i, swizzle = 0;
415
416    assert(format);
417
418    if (desc->layout != UTIL_FORMAT_LAYOUT_PLAIN) {
419        fprintf(stderr, "r300: Bad format %s in %s:%d\n",
420            util_format_short_name(format), __FUNCTION__, __LINE__);
421        return 0;
422    }
423
424    for (i = 0; i < desc->nr_channels; i++) {
425        swizzle |=
426            MIN2(desc->swizzle[i], R300_SWIZZLE_SELECT_FP_ONE) << (3*i);
427    }
428    /* Set (0,0,0,1) in unused components. */
429    for (; i < 3; i++) {
430        swizzle |= R300_SWIZZLE_SELECT_FP_ZERO << (3*i);
431    }
432    for (; i < 4; i++) {
433        swizzle |= R300_SWIZZLE_SELECT_FP_ONE << (3*i);
434    }
435
436    return swizzle | (0xf << R300_WRITE_ENA_SHIFT);
437}
438
439#endif /* R300_STATE_INLINES_H */
440