#include <stdio.h>
-#include "mtypes.h"
+//#include "mtypes.h"
#include "i915_context.h"
#include "i915_winsys.h"
void
i915_fill_blit(struct i915_context *i915,
- GLuint cpp,
- GLshort dst_pitch,
+ unsigned cpp,
+ short dst_pitch,
struct pipe_buffer_handle *dst_buffer,
- GLuint dst_offset,
- GLshort x, GLshort y,
- GLshort w, GLshort h,
- GLuint color)
+ unsigned dst_offset,
+ short x, short y,
+ short w, short h,
+ unsigned color)
{
- GLuint BR13, CMD;
+ unsigned BR13, CMD;
BATCH_LOCALS;
dst_pitch *= cpp;
void
i915_copy_blit( struct i915_context *i915,
- GLuint cpp,
- GLshort src_pitch,
+ unsigned cpp,
+ short src_pitch,
struct pipe_buffer_handle *src_buffer,
- GLuint src_offset,
- GLshort dst_pitch,
+ unsigned src_offset,
+ short dst_pitch,
struct pipe_buffer_handle *dst_buffer,
- GLuint dst_offset,
- GLshort src_x, GLshort src_y,
- GLshort dst_x, GLshort dst_y,
- GLshort w, GLshort h )
+ unsigned dst_offset,
+ short src_x, short src_y,
+ short dst_x, short dst_y,
+ short w, short h )
{
- GLuint CMD, BR13;
+ unsigned CMD, BR13;
int dst_y2 = dst_y + h;
int dst_x2 = dst_x + w;
BATCH_LOCALS;
case 1:
case 2:
case 3:
- BR13 = (((GLint) dst_pitch) & 0xffff) |
+ BR13 = (((int) dst_pitch) & 0xffff) |
(0xCC << 16) | (1 << 24);
CMD = XY_SRC_COPY_BLT_CMD;
break;
case 4:
BR13 =
- (((GLint) dst_pitch) & 0xffff) |
+ (((int) dst_pitch) & 0xffff) |
(0xCC << 16) | (1 << 24) | (1 << 25);
CMD =
(XY_SRC_COPY_BLT_CMD | XY_SRC_COPY_BLT_WRITE_ALPHA |
OUT_BATCH((dst_y2 << 16) | dst_x2);
OUT_RELOC(dst_buffer, I915_BUFFER_ACCESS_WRITE, dst_offset);
OUT_BATCH((src_y << 16) | src_x);
- OUT_BATCH(((GLint) src_pitch & 0xffff));
+ OUT_BATCH(((int) src_pitch & 0xffff));
OUT_RELOC(src_buffer, I915_BUFFER_ACCESS_READ, src_offset);
ADVANCE_BATCH();
}
#include "i915_context.h"
extern void i915_copy_blit(struct i915_context *i915,
- GLuint cpp,
- GLshort src_pitch,
+ unsigned cpp,
+ short src_pitch,
struct pipe_buffer_handle *src_buffer,
- GLuint src_offset,
- GLshort dst_pitch,
+ unsigned src_offset,
+ short dst_pitch,
struct pipe_buffer_handle *dst_buffer,
- GLuint dst_offset,
- GLshort srcx, GLshort srcy,
- GLshort dstx, GLshort dsty,
- GLshort w, GLshort h );
+ unsigned dst_offset,
+ short srcx, short srcy,
+ short dstx, short dsty,
+ short w, short h );
extern void i915_fill_blit(struct i915_context *i915,
- GLuint cpp,
- GLshort dst_pitch,
+ unsigned cpp,
+ short dst_pitch,
struct pipe_buffer_handle *dst_buffer,
- GLuint dst_offset,
- GLshort x, GLshort y,
- GLshort w, GLshort h, GLuint color);
+ unsigned dst_offset,
+ short x, short y,
+ short w, short h, unsigned color);
#endif
#include "pipe/p_defines.h"
#include "i915_context.h"
#include "i915_state.h"
-#include "colormac.h"
+//#include "colormac.h"
/**
*/
void
i915_clear(struct pipe_context *pipe, struct pipe_surface *ps,
- GLuint clearValue)
+ unsigned clearValue)
{
- GLint x, y, w, h;
+ int x, y, w, h;
x = 0;
y = 0;
*
**************************************************************************/
-#include "main/imports.h" /* CALLOC */
+//#include "main/imports.h" /* CALLOC */
#include "i915_context.h"
#include "i915_winsys.h"
#include "i915_state.h"
#include "pipe/draw/draw_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_winsys.h"
+#include "pipe/p_util.h"
/**
* If we find texture and drawable support differs, add a selector
* parameter or another function.
*/
-static const GLuint *
+static const unsigned *
i915_supported_formats(struct pipe_context *pipe,
-// GLuint type,
- GLuint *numFormats)
+// unsigned type,
+ unsigned *numFormats)
{
#if 0
- static const GLuint tex_supported[] = {
+ static const unsigned tex_supported[] = {
PIPE_FORMAT_U_R8_G8_B8_A8,
PIPE_FORMAT_U_A8_R8_G8_B8,
PIPE_FORMAT_U_R5_G6_B5,
/* Actually a lot more than this - add later:
*/
- static const GLuint render_supported[] = {
+ static const unsigned render_supported[] = {
PIPE_FORMAT_U_A8_R8_G8_B8,
PIPE_FORMAT_U_R5_G6_B5,
};
/*
*/
- static const GLuint z_stencil_supported[] = {
+ static const unsigned z_stencil_supported[] = {
PIPE_FORMAT_U_Z16,
PIPE_FORMAT_U_Z32,
PIPE_FORMAT_S8_Z24,
return NULL;
}
#else
- static const GLuint render_supported[] = {
+ static const unsigned render_supported[] = {
PIPE_FORMAT_U_A8_R8_G8_B8,
PIPE_FORMAT_U_R5_G6_B5,
PIPE_FORMAT_S8_Z24,
* We might want to return max texture levels instead...
*/
static void
-i915_max_texture_size(struct pipe_context *pipe, GLuint textureType,
- GLuint *maxWidth, GLuint *maxHeight, GLuint *maxDepth)
+i915_max_texture_size(struct pipe_context *pipe, unsigned textureType,
+ unsigned *maxWidth, unsigned *maxHeight, unsigned *maxDepth)
{
switch (textureType) {
case PIPE_TEXTURE_1D:
static void
i915_draw_vertices(struct pipe_context *pipe,
- GLuint mode,
- GLuint numVertex, const GLfloat *verts,
- GLuint numAttribs, const GLuint attribs[])
+ unsigned mode,
+ unsigned numVertex, const float *verts,
+ unsigned numAttribs, const unsigned attribs[])
{
struct i915_context *i915 = i915_context( pipe );
*/
struct i915_state
{
- GLuint immediate[I915_MAX_IMMEDIATE];
- GLuint dynamic[I915_MAX_DYNAMIC];
+ unsigned immediate[I915_MAX_IMMEDIATE];
+ unsigned dynamic[I915_MAX_DYNAMIC];
- GLuint id; /* track lost context events */
+ unsigned id; /* track lost context events */
};
struct pipe_stencil_state stencil;
struct pipe_mipmap_tree *texture[PIPE_MAX_SAMPLERS];
struct pipe_viewport_state viewport;
- GLuint dirty;
+ unsigned dirty;
- GLuint *batch_start;
+ unsigned *batch_start;
struct i915_state current;
- GLuint hardware_dirty;
+ unsigned hardware_dirty;
- GLuint debug;
- GLuint pci_id;
+ unsigned debug;
+ unsigned pci_id;
struct {
unsigned is_i945:1;
* i915_clear.c:
*/
void i915_clear(struct pipe_context *pipe, struct pipe_surface *ps,
- GLuint clearValue);
+ unsigned clearValue);
/***********************************************************************
*
**************************************************************************/
-#include "imports.h"
+//#include "imports.h"
#include "i915_reg.h"
#include "i915_context.h"
#define PRINTF( ... ) (stream)->winsys->printf( (stream)->winsys, __VA_ARGS__ )
-static GLboolean debug( struct debug_stream *stream, const char *name, GLuint len )
+static boolean debug( struct debug_stream *stream, const char *name, unsigned len )
{
- GLuint i;
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
+ unsigned i;
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
if (len == 0) {
PRINTF("Error - zero length packet (0x%08x)\n", stream->ptr[0]);
assert(0);
- return GL_FALSE;
+ return FALSE;
}
if (stream->print_addresses)
PRINTF("\t0x%08x\n", ptr[i]);
PRINTF("\n");
- stream->offset += len * sizeof(GLuint);
+ stream->offset += len * sizeof(unsigned);
- return GL_TRUE;
+ return TRUE;
}
-static const char *get_prim_name( GLuint val )
+static const char *get_prim_name( unsigned val )
{
switch (val & PRIM3D_MASK) {
case PRIM3D_TRILIST: return "TRILIST"; break;
}
}
-static GLboolean debug_prim( struct debug_stream *stream, const char *name,
- GLboolean dump_floats,
- GLuint len )
+static boolean debug_prim( struct debug_stream *stream, const char *name,
+ boolean dump_floats,
+ unsigned len )
{
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
const char *prim = get_prim_name( ptr[0] );
- GLuint i;
+ unsigned i;
PRINTF("\t0x%08x\n", ptr[0]);
for (i = 1; i < len; i++) {
if (dump_floats)
- PRINTF("\t0x%08x // %f\n", ptr[i], *(GLfloat *)&ptr[i]);
+ PRINTF("\t0x%08x // %f\n", ptr[i], *(float *)&ptr[i]);
else
PRINTF("\t0x%08x\n", ptr[i]);
}
PRINTF("\n");
- stream->offset += len * sizeof(GLuint);
+ stream->offset += len * sizeof(unsigned);
- return GL_TRUE;
+ return TRUE;
}
-static GLboolean debug_program( struct debug_stream *stream, const char *name, GLuint len )
+static boolean debug_program( struct debug_stream *stream, const char *name, unsigned len )
{
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
if (len == 0) {
PRINTF("Error - zero length packet (0x%08x)\n", stream->ptr[0]);
assert(0);
- return GL_FALSE;
+ return FALSE;
}
if (stream->print_addresses)
PRINTF("%s (%d dwords):\n", name, len);
i915_disassemble_program( stream, ptr, len );
- stream->offset += len * sizeof(GLuint);
- return GL_TRUE;
+ stream->offset += len * sizeof(unsigned);
+ return TRUE;
}
-static GLboolean debug_chain( struct debug_stream *stream, const char *name, GLuint len )
+static boolean debug_chain( struct debug_stream *stream, const char *name, unsigned len )
{
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
- GLuint old_offset = stream->offset + len * sizeof(GLuint);
- GLuint i;
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
+ unsigned old_offset = stream->offset + len * sizeof(unsigned);
+ unsigned i;
PRINTF("%s (%d dwords):\n", name, len);
for (i = 0; i < len; i++)
old_offset, stream->offset );
- return GL_TRUE;
+ return TRUE;
}
-static GLboolean debug_variable_length_prim( struct debug_stream *stream )
+static boolean debug_variable_length_prim( struct debug_stream *stream )
{
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
const char *prim = get_prim_name( ptr[0] );
- GLuint i, len;
+ unsigned i, len;
- GLushort *idx = (GLushort *)(ptr+1);
+ ushort *idx = (ushort *)(ptr+1);
for (i = 0; idx[i] != 0xffff; i++)
;
PRINTF("\t0x%08x\n", ptr[i]);
PRINTF("\n");
- stream->offset += len * sizeof(GLuint);
- return GL_TRUE;
+ stream->offset += len * sizeof(unsigned);
+ return TRUE;
}
} \
} while (0)
-static GLboolean debug_load_immediate( struct debug_stream *stream,
+static boolean debug_load_immediate( struct debug_stream *stream,
const char *name,
- GLuint len )
+ unsigned len )
{
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
- GLuint bits = (ptr[0] >> 4) & 0xff;
- GLuint j = 0;
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
+ unsigned bits = (ptr[0] >> 4) & 0xff;
+ unsigned j = 0;
PRINTF("%s (%d dwords, flags: %x):\n", name, len, bits);
PRINTF("\t0x%08x\n", ptr[j++]);
assert(j == len);
- stream->offset += len * sizeof(GLuint);
+ stream->offset += len * sizeof(unsigned);
- return GL_TRUE;
+ return TRUE;
}
-static GLboolean debug_load_indirect( struct debug_stream *stream,
+static boolean debug_load_indirect( struct debug_stream *stream,
const char *name,
- GLuint len )
+ unsigned len )
{
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
- GLuint bits = (ptr[0] >> 8) & 0x3f;
- GLuint i, j = 0;
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
+ unsigned bits = (ptr[0] >> 8) & 0x3f;
+ unsigned i, j = 0;
PRINTF("%s (%d dwords):\n", name, len);
PRINTF("\t0x%08x\n", ptr[j++]);
assert(j == len);
- stream->offset += len * sizeof(GLuint);
+ stream->offset += len * sizeof(unsigned);
- return GL_TRUE;
+ return TRUE;
}
static void BR13( struct debug_stream *stream,
- GLuint val )
+ unsigned val )
{
PRINTF("\t0x%08x\n", val);
FLAG(val, 30, "clipping enable");
static void BR22( struct debug_stream *stream,
- GLuint val )
+ unsigned val )
{
PRINTF("\t0x%08x\n", val);
BITS(val, 31, 16, "dest y1");
}
static void BR23( struct debug_stream *stream,
- GLuint val )
+ unsigned val )
{
PRINTF("\t0x%08x\n", val);
BITS(val, 31, 16, "dest y2");
}
static void BR09( struct debug_stream *stream,
- GLuint val )
+ unsigned val )
{
PRINTF("\t0x%08x -- dest address\n", val);
}
static void BR26( struct debug_stream *stream,
- GLuint val )
+ unsigned val )
{
PRINTF("\t0x%08x\n", val);
BITS(val, 31, 16, "src y1");
}
static void BR11( struct debug_stream *stream,
- GLuint val )
+ unsigned val )
{
PRINTF("\t0x%08x\n", val);
BITS(val, 15, 0, "src pitch");
}
static void BR12( struct debug_stream *stream,
- GLuint val )
+ unsigned val )
{
PRINTF("\t0x%08x -- src address\n", val);
}
static void BR16( struct debug_stream *stream,
- GLuint val )
+ unsigned val )
{
PRINTF("\t0x%08x -- color\n", val);
}
-static GLboolean debug_copy_blit( struct debug_stream *stream,
+static boolean debug_copy_blit( struct debug_stream *stream,
const char *name,
- GLuint len )
+ unsigned len )
{
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
int j = 0;
PRINTF("%s (%d dwords):\n", name, len);
BR11(stream, ptr[j++]);
BR12(stream, ptr[j++]);
- stream->offset += len * sizeof(GLuint);
+ stream->offset += len * sizeof(unsigned);
assert(j == len);
- return GL_TRUE;
+ return TRUE;
}
-static GLboolean debug_color_blit( struct debug_stream *stream,
+static boolean debug_color_blit( struct debug_stream *stream,
const char *name,
- GLuint len )
+ unsigned len )
{
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
int j = 0;
PRINTF("%s (%d dwords):\n", name, len);
BR09(stream, ptr[j++]);
BR16(stream, ptr[j++]);
- stream->offset += len * sizeof(GLuint);
+ stream->offset += len * sizeof(unsigned);
assert(j == len);
- return GL_TRUE;
+ return TRUE;
}
-static GLboolean debug_modes4( struct debug_stream *stream,
+static boolean debug_modes4( struct debug_stream *stream,
const char *name,
- GLuint len )
+ unsigned len )
{
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
int j = 0;
PRINTF("%s (%d dwords):\n", name, len);
BITS(ptr[j], 7, 0, "stencil write mask");
j++;
- stream->offset += len * sizeof(GLuint);
+ stream->offset += len * sizeof(unsigned);
assert(j == len);
- return GL_TRUE;
+ return TRUE;
}
-static GLboolean debug_map_state( struct debug_stream *stream,
+static boolean debug_map_state( struct debug_stream *stream,
const char *name,
- GLuint len )
+ unsigned len )
{
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
int j = 0;
PRINTF("%s (%d dwords):\n", name, len);
}
}
- stream->offset += len * sizeof(GLuint);
+ stream->offset += len * sizeof(unsigned);
assert(j == len);
- return GL_TRUE;
+ return TRUE;
}
-static GLboolean debug_sampler_state( struct debug_stream *stream,
+static boolean debug_sampler_state( struct debug_stream *stream,
const char *name,
- GLuint len )
+ unsigned len )
{
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
int j = 0;
PRINTF("%s (%d dwords):\n", name, len);
}
}
- stream->offset += len * sizeof(GLuint);
+ stream->offset += len * sizeof(unsigned);
assert(j == len);
- return GL_TRUE;
+ return TRUE;
}
-static GLboolean debug_dest_vars( struct debug_stream *stream,
+static boolean debug_dest_vars( struct debug_stream *stream,
const char *name,
- GLuint len )
+ unsigned len )
{
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
int j = 0;
PRINTF("%s (%d dwords):\n", name, len);
j++;
}
- stream->offset += len * sizeof(GLuint);
+ stream->offset += len * sizeof(unsigned);
assert(j == len);
- return GL_TRUE;
+ return TRUE;
}
-static GLboolean debug_buf_info( struct debug_stream *stream,
+static boolean debug_buf_info( struct debug_stream *stream,
const char *name,
- GLuint len )
+ unsigned len )
{
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
int j = 0;
PRINTF("%s (%d dwords):\n", name, len);
PRINTF("\t0x%08x -- buffer base address\n", ptr[j++]);
- stream->offset += len * sizeof(GLuint);
+ stream->offset += len * sizeof(unsigned);
assert(j == len);
- return GL_TRUE;
+ return TRUE;
}
-static GLboolean i915_debug_packet( struct debug_stream *stream )
+static boolean i915_debug_packet( struct debug_stream *stream )
{
- GLuint *ptr = (GLuint *)(stream->ptr + stream->offset);
- GLuint cmd = *ptr;
+ unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
+ unsigned cmd = *ptr;
switch (((cmd >> 29) & 0x7)) {
case 0x0:
return debug(stream, "MI_FLUSH", 1);
case 0xA:
debug(stream, "MI_BATCH_BUFFER_END", 1);
- return GL_FALSE;
+ return FALSE;
case 0x22:
return debug(stream, "MI_LOAD_REGISTER_IMM", 3);
case 0x31:
void
i915_dump_batchbuffer( struct i915_context *i915,
- GLuint *start,
- GLuint *end )
+ unsigned *start,
+ unsigned *end )
{
struct debug_stream stream;
- GLuint bytes = (end - start) * 4;
- GLboolean done = GL_FALSE;
+ unsigned bytes = (end - start) * 4;
+ boolean done = FALSE;
stream.offset = 0;
*
**************************************************************************/
-#include <stdio.h>
#include "i915_reg.h"
#include "i915_debug.h"
#include "pipe/p_winsys.h"
-//#include "i915_fpc.h"
-#include "shader/program.h"
-#include "shader/prog_instruction.h"
-#include "shader/prog_print.h"
+#include "pipe/p_util.h"
+
};
static void
-print_reg_type_nr(struct debug_stream *stream, GLuint type, GLuint nr)
+print_reg_type_nr(struct debug_stream *stream, unsigned type, unsigned nr)
{
switch (type) {
case REG_TYPE_T:
static void
-print_reg_neg_swizzle(struct debug_stream *stream, GLuint reg)
+print_reg_neg_swizzle(struct debug_stream *stream, unsigned reg)
{
int i;
static void
-print_src_reg(struct debug_stream *stream, GLuint dword)
+print_src_reg(struct debug_stream *stream, unsigned dword)
{
- GLuint nr = (dword >> A2_SRC2_NR_SHIFT) & REG_NR_MASK;
- GLuint type = (dword >> A2_SRC2_TYPE_SHIFT) & REG_TYPE_MASK;
+ unsigned nr = (dword >> A2_SRC2_NR_SHIFT) & REG_NR_MASK;
+ unsigned type = (dword >> A2_SRC2_TYPE_SHIFT) & REG_TYPE_MASK;
print_reg_type_nr(stream, type, nr);
print_reg_neg_swizzle(stream, dword);
}
static void
-print_dest_reg(struct debug_stream *stream, GLuint dword)
+print_dest_reg(struct debug_stream *stream, unsigned dword)
{
- GLuint nr = (dword >> A0_DEST_NR_SHIFT) & REG_NR_MASK;
- GLuint type = (dword >> A0_DEST_TYPE_SHIFT) & REG_TYPE_MASK;
+ unsigned nr = (dword >> A0_DEST_NR_SHIFT) & REG_NR_MASK;
+ unsigned type = (dword >> A0_DEST_TYPE_SHIFT) & REG_TYPE_MASK;
print_reg_type_nr(stream, type, nr);
if ((dword & A0_DEST_CHANNEL_ALL) == A0_DEST_CHANNEL_ALL)
return;
static void
print_arith_op(struct debug_stream *stream,
- GLuint opcode, const GLuint * program)
+ unsigned opcode, const unsigned * program)
{
if (opcode != A0_NOP) {
print_dest_reg(stream, program[0]);
static void
print_tex_op(struct debug_stream *stream,
- GLuint opcode, const GLuint * program)
+ unsigned opcode, const unsigned * program)
{
print_dest_reg(stream, program[0] | A0_DEST_CHANNEL_ALL);
PRINTF(" = ");
static void
print_dcl_op(struct debug_stream *stream,
- GLuint opcode, const GLuint * program)
+ unsigned opcode, const unsigned * program)
{
PRINTF("%s ", opcodes[opcode]);
print_dest_reg(stream,
void
i915_disassemble_program(struct debug_stream *stream,
- const GLuint * program, GLuint sz)
+ const unsigned * program, unsigned sz)
{
- GLuint size = program[0] & 0x1ff;
- GLint i;
+ unsigned size = program[0] & 0x1ff;
+ int i;
PRINTF("\t\tBEGIN\n");
program++;
for (i = 1; i < sz; i += 3, program += 3) {
- GLuint opcode = program[0] & (0x1f << 24);
+ unsigned opcode = program[0] & (0x1f << 24);
PRINTF("\t\t");
- if ((GLint) opcode >= A0_NOP && opcode <= A0_SLT)
+ if ((int) opcode >= A0_NOP && opcode <= A0_SLT)
print_arith_op(stream, opcode >> 24, program);
else if (opcode >= T0_TEXLD && opcode <= T0_TEXKILL)
print_tex_op(stream, opcode >> 24, program);
**************************************************************************/
-#include "imports.h"
-#include "macros.h"
+//#include "imports.h"
+//#include "macros.h"
#include "pipe/draw/draw_private.h"
+#include "pipe/p_util.h"
#include "i915_context.h"
#include "i915_winsys.h"
return (struct setup_stage *)stage;
}
-static INLINE unsigned pack_ub4( unsigned char b0,
- unsigned char b1,
- unsigned char b2,
- unsigned char b3 )
-{
- return ((((unsigned int)b0) << 0) |
- (((unsigned int)b1) << 8) |
- (((unsigned int)b2) << 16) |
- (((unsigned int)b3) << 24));
-}
-
-static INLINE unsigned fui( float f )
-{
- union {
- float f;
- unsigned ui;
- } fi;
-
- fi.f = f;
- return fi.ui;
-}
-
-static INLINE unsigned char float_to_ubyte( float f )
-{
- unsigned char ub;
- UNCLAMPED_FLOAT_TO_UBYTE(ub, f);
- return ub;
-}
/* Hardcoded vertex format: xyz/rgba
}
-static GLubyte *
+static ubyte *
i915_region_map(struct pipe_context *pipe, struct pipe_region *region)
{
struct i915_context *i915 = i915_context( pipe );
static struct pipe_region *
i915_region_alloc(struct pipe_context *pipe,
- GLuint cpp, GLuint width, GLuint height, GLbitfield flags)
+ unsigned cpp, unsigned width, unsigned height, unsigned flags)
{
struct i915_context *i915 = i915_context( pipe );
struct pipe_region *region = calloc(sizeof(*region), 1);
if (!*region)
return;
- ASSERT((*region)->refcount > 0);
+ assert((*region)->refcount > 0);
(*region)->refcount--;
if ((*region)->refcount == 0) {
* XXX Move this into core Mesa?
*/
static void
-_mesa_copy_rect(GLubyte * dst,
- GLuint cpp,
- GLuint dst_pitch,
- GLuint dst_x,
- GLuint dst_y,
- GLuint width,
- GLuint height,
- const GLubyte * src,
- GLuint src_pitch,
- GLuint src_x,
- GLuint src_y)
+_mesa_copy_rect(ubyte * dst,
+ unsigned cpp,
+ unsigned dst_pitch,
+ unsigned dst_x,
+ unsigned dst_y,
+ unsigned width,
+ unsigned height,
+ const ubyte * src,
+ unsigned src_pitch,
+ unsigned src_x,
+ unsigned src_y)
{
- GLuint i;
+ unsigned i;
dst_pitch *= cpp;
src_pitch *= cpp;
static void
i915_region_data(struct pipe_context *pipe,
struct pipe_region *dst,
- GLuint dst_offset,
- GLuint dstx, GLuint dsty,
- const void *src, GLuint src_pitch,
- GLuint srcx, GLuint srcy, GLuint width, GLuint height)
+ unsigned dst_offset,
+ unsigned dstx, unsigned dsty,
+ const void *src, unsigned src_pitch,
+ unsigned srcx, unsigned srcy, unsigned width, unsigned height)
{
_mesa_copy_rect(pipe->region_map(pipe, dst) + dst_offset,
dst->cpp,
static void
i915_region_copy(struct pipe_context *pipe,
struct pipe_region *dst,
- GLuint dst_offset,
- GLuint dstx, GLuint dsty,
+ unsigned dst_offset,
+ unsigned dstx, unsigned dsty,
struct pipe_region *src,
- GLuint src_offset,
- GLuint srcx, GLuint srcy, GLuint width, GLuint height)
+ unsigned src_offset,
+ unsigned srcx, unsigned srcy, unsigned width, unsigned height)
{
assert( dst != src );
assert( dst->cpp == src->cpp );
/* Fill a rectangular sub-region. Need better logic about when to
* push buffers into AGP - will currently do so whenever possible.
*/
-static GLubyte *
-get_pointer(struct pipe_region *dst, GLuint x, GLuint y)
+static ubyte *
+get_pointer(struct pipe_region *dst, unsigned x, unsigned y)
{
return dst->map + (y * dst->pitch + x) * dst->cpp;
}
static void
i915_region_fill(struct pipe_context *pipe,
struct pipe_region *dst,
- GLuint dst_offset,
- GLuint dstx, GLuint dsty,
- GLuint width, GLuint height, GLuint value)
+ unsigned dst_offset,
+ unsigned dstx, unsigned dsty,
+ unsigned width, unsigned height, unsigned value)
{
if (0) {
- GLuint i, j;
+ unsigned i, j;
(void)pipe->region_map(pipe, dst);
switch (dst->cpp) {
case 1: {
- GLubyte *row = get_pointer(dst, dstx, dsty);
+ ubyte *row = get_pointer(dst, dstx, dsty);
for (i = 0; i < height; i++) {
memset(row, value, width);
row += dst->pitch;
}
break;
case 2: {
- GLushort *row = (GLushort *) get_pointer(dst, dstx, dsty);
+ ushort *row = (ushort *) get_pointer(dst, dstx, dsty);
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++)
row[j] = value;
}
break;
case 4: {
- GLuint *row = (GLuint *) get_pointer(dst, dstx, dsty);
+ unsigned *row = (unsigned *) get_pointer(dst, dstx, dsty);
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++)
row[j] = value;
/* Authors: Keith Whitwell <keith@tungstengraphics.com>
*/
-#include "imports.h"
+//#include "imports.h"
#include "pipe/draw/draw_context.h"
static void i915_set_sampler_state(struct pipe_context *pipe,
- GLuint unit,
+ unsigned unit,
const struct pipe_sampler_state *sampler)
{
struct i915_context *i915 = i915_context(pipe);
static void i915_set_texture_state(struct pipe_context *pipe,
- GLuint unit,
+ unsigned unit,
struct pipe_mipmap_tree *texture)
{
struct i915_context *i915 = i915_context(pipe);
} while (0)
-static const GLuint frag_to_vf[FRAG_ATTRIB_MAX] =
+static const unsigned frag_to_vf[FRAG_ATTRIB_MAX] =
{
VF_ATTRIB_POS,
VF_ATTRIB_COLOR0,
*/
static void calculate_vertex_layout( struct i915_context *i915 )
{
-// const GLbitfield inputsRead = i915->fs.inputs_read;
- const GLbitfield inputsRead = (FRAG_BIT_WPOS | FRAG_BIT_COL0);
- GLuint slot_to_vf_attr[VF_ATTRIB_MAX];
- GLbitfield attr_mask = 0x0;
- GLuint nr_attrs = 0;
- GLuint i;
+// const unsigned inputsRead = i915->fs.inputs_read;
+ const unsigned inputsRead = (FRAG_BIT_WPOS | FRAG_BIT_COL0);
+ unsigned slot_to_vf_attr[VF_ATTRIB_MAX];
+ unsigned attr_mask = 0x0;
+ unsigned nr_attrs = 0;
+ unsigned i;
memset(slot_to_vf_attr, 0, sizeof(slot_to_vf_attr));
*
**************************************************************************/
-#include "glheader.h"
-#include "context.h"
-#include "macros.h"
-#include "enums.h"
+//#include "glheader.h"
+//#include "context.h"
+//#include "macros.h"
+//#include "enums.h"
#include "i915_batch.h"
#include "i915_state_inlines.h"
#include "i915_context.h"
#include "i915_reg.h"
#include "i915_state.h"
+#include "pipe/p_util.h"
#define FILE_DEBUG_FLAG DEBUG_STATE
*/
static inline void set_dynamic_indirect( struct i915_context *i915,
- GLuint offset,
- const GLuint *src,
- GLuint dwords )
+ unsigned offset,
+ const unsigned *src,
+ unsigned dwords )
{
int i;
*/
static void upload_MODES4( struct i915_context *i915 )
{
- GLuint modes4 = 0;
+ unsigned modes4 = 0;
/* I915_NEW_STENCIL */
{
- GLint testmask = i915->stencil.value_mask[0] & 0xff;
- GLint writemask = i915->stencil.write_mask[0] & 0xff;
+ int testmask = i915->stencil.value_mask[0] & 0xff;
+ int writemask = i915->stencil.write_mask[0] & 0xff;
modes4 |= (_3DSTATE_MODES_4_CMD |
ENABLE_STENCIL_TEST_MASK |
static void upload_BFO( struct i915_context *i915 )
{
- GLuint bf[2];
+ unsigned bf[2];
memset( bf, 0, sizeof(bf) );
/* _NEW_STENCIL
*/
if (i915->stencil.back_enabled) {
- GLint test = i915_translate_compare_func(i915->stencil.back_func);
- GLint fop = i915_translate_stencil_op(i915->stencil.back_fail_op);
- GLint dfop = i915_translate_stencil_op(i915->stencil.back_zfail_op);
- GLint dpop = i915_translate_stencil_op(i915->stencil.back_zpass_op);
- GLint ref = i915->stencil.ref_value[1] & 0xff;
- GLint tmask = i915->stencil.value_mask[1] & 0xff;
- GLint wmask = i915->stencil.write_mask[1] & 0xff;
+ int test = i915_translate_compare_func(i915->stencil.back_func);
+ int fop = i915_translate_stencil_op(i915->stencil.back_fail_op);
+ int dfop = i915_translate_stencil_op(i915->stencil.back_zfail_op);
+ int dpop = i915_translate_stencil_op(i915->stencil.back_zpass_op);
+ int ref = i915->stencil.ref_value[1] & 0xff;
+ int tmask = i915->stencil.value_mask[1] & 0xff;
+ int wmask = i915->stencil.write_mask[1] & 0xff;
bf[0] = (_3DSTATE_BACKFACE_STENCIL_OPS |
BFO_ENABLE_STENCIL_FUNCS |
static void upload_BLENDCOLOR( struct i915_context *i915 )
{
- GLuint bc[2];
+ unsigned bc[2];
memset( bc, 0, sizeof(bc) );
/* I915_NEW_BLEND {_COLOR}
*/
{
- const GLfloat *color = i915->blend_color.color;
- GLubyte r, g, b, a;
+ const float *color = i915->blend_color.color;
- UNCLAMPED_FLOAT_TO_UBYTE(r, color[RCOMP]);
- UNCLAMPED_FLOAT_TO_UBYTE(g, color[GCOMP]);
- UNCLAMPED_FLOAT_TO_UBYTE(b, color[BCOMP]);
- UNCLAMPED_FLOAT_TO_UBYTE(a, color[ACOMP]);
-
- bc[0] = (_3DSTATE_CONST_BLEND_COLOR_CMD);
- bc[1] = (a << 24) | (r << 16) | (g << 8) | b;
+ bc[0] = _3DSTATE_CONST_BLEND_COLOR_CMD;
+ bc[1] = pack_ui32_float4( color[0],
+ color[1],
+ color[2],
+ color[3] );
}
set_dynamic_indirect( i915,
static void upload_IAB( struct i915_context *i915 )
{
- GLuint iab = 0;
+ unsigned iab = 0;
{
- GLuint eqRGB = i915->blend.rgb_func;
- GLuint srcRGB = i915->blend.rgb_src_factor;
- GLuint dstRGB = i915->blend.rgb_dst_factor;
+ unsigned eqRGB = i915->blend.rgb_func;
+ unsigned srcRGB = i915->blend.rgb_src_factor;
+ unsigned dstRGB = i915->blend.rgb_dst_factor;
- GLuint eqA = i915->blend.alpha_func;
- GLuint srcA = i915->blend.alpha_src_factor;
- GLuint dstA = i915->blend.alpha_dst_factor;
+ unsigned eqA = i915->blend.alpha_func;
+ unsigned srcA = i915->blend.alpha_src_factor;
+ unsigned dstA = i915->blend.alpha_dst_factor;
- if (eqA == GL_MIN || eqA == GL_MAX) {
- srcA = dstA = GL_ONE;
- }
+ /* Special handling for MIN/MAX filter modes handled at
+ * state_tracker level.
+ */
- if (eqRGB == GL_MIN || eqRGB == GL_MAX) {
- srcRGB = dstRGB = GL_ONE;
- }
-
if (srcA != srcRGB ||
dstA != dstRGB ||
eqA != eqRGB) {
static void upload_DEPTHSCALE( struct i915_context *i915 )
{
- union { GLfloat f; GLuint u; } ds[2];
+ union { float f; unsigned u; } ds[2];
memset( ds, 0, sizeof(ds) );
static void upload_STIPPLE( struct i915_context *i915 )
{
- GLuint st[2];
+ unsigned st[2];
st[0] = _3DSTATE_STIPPLE;
st[1] = 0;
/* I915_NEW_STIPPLE
*/
{
- const GLubyte *mask = (const GLubyte *)i915->poly_stipple.stipple;
- GLubyte p[4];
+ const ubyte *mask = (const ubyte *)i915->poly_stipple.stipple;
+ ubyte p[4];
p[0] = mask[12] & 0xf;
p[1] = mask[8] & 0xf;
-#include "glheader.h"
-#include "mtypes.h"
+//#include "glheader.h"
+//#include "mtypes.h"
#include "i915_reg.h"
#include "i915_context.h"
{
- GLuint i, dwords;
- GLuint *prog = i915_passthrough_program( &dwords );
+ unsigned i, dwords;
+ unsigned *prog = i915_passthrough_program( &dwords );
for (i = 0; i < dwords; i++)
OUT_BATCH( prog[i] );
#include "i915_reg.h"
#include "i915_context.h"
#include "i915_debug.h"
-
+#include "pipe/p_util.h"
static unsigned passthrough[] =
{
* Keith Whitwell <keith@tungstengraphics.com>
*/
-#include "macros.h"
+//#include "macros.h"
#include "i915_state_inlines.h"
#include "i915_context.h"
#include "i915_state.h"
#include "i915_reg.h"
+#include "p_util.h"
/* All state expressable with the LOAD_STATE_IMMEDIATE_1 packet.
*/
static void upload_S2S4(struct i915_context *i915)
{
- GLuint LIS2, LIS4;
+ unsigned LIS2, LIS4;
/* I915_NEW_VERTEX_FORMAT */
LIS2 = 0xffffffff;
/* I915_NEW_SETUP */
{
- GLint point_size = CLAMP((int) i915->setup.point_size, 1, 0xff);
+ int point_size = CLAMP((int) i915->setup.point_size, 1, 0xff);
LIS4 |= point_size << S4_POINT_WIDTH_SHIFT;
}
*/
static void upload_S5( struct i915_context *i915 )
{
- GLuint LIS5 = 0;
+ unsigned LIS5 = 0;
/* I915_NEW_STENCIL */
if (i915->stencil.front_enabled) {
- GLint test = i915_translate_compare_func(i915->stencil.front_func);
- GLint fop = i915_translate_stencil_op(i915->stencil.front_fail_op);
- GLint dfop = i915_translate_stencil_op(i915->stencil.front_zfail_op);
- GLint dpop = i915_translate_stencil_op(i915->stencil.front_zpass_op);
- GLint ref = i915->stencil.ref_value[0] & 0xff;
+ int test = i915_translate_compare_func(i915->stencil.front_func);
+ int fop = i915_translate_stencil_op(i915->stencil.front_fail_op);
+ int dfop = i915_translate_stencil_op(i915->stencil.front_zfail_op);
+ int dpop = i915_translate_stencil_op(i915->stencil.front_zpass_op);
+ int ref = i915->stencil.ref_value[0] & 0xff;
LIS5 |= (S5_STENCIL_TEST_ENABLE |
S5_STENCIL_WRITE_ENABLE |
*/
static void upload_S6( struct i915_context *i915 )
{
- GLuint LIS6 = (S6_COLOR_WRITE_ENABLE |
+ unsigned LIS6 = (S6_COLOR_WRITE_ENABLE |
(2 << S6_TRISTRIP_PV_SHIFT));
/* I915_NEW_ALPHA_TEST
*/
if (i915->alpha_test.enabled) {
int test = i915_translate_compare_func(i915->alpha_test.func);
- GLubyte refByte;
-
- CLAMPED_FLOAT_TO_UBYTE(refByte, i915->alpha_test.ref);
+ ubyte refByte = float_to_ubyte(i915->alpha_test.ref);
LIS6 |= (S6_ALPHA_TEST_ENABLE |
*/
if (i915->blend.blend_enable)
{
- GLuint funcRGB = i915->blend.rgb_func;
- GLuint srcRGB = i915->blend.rgb_src_factor;
- GLuint dstRGB = i915->blend.rgb_dst_factor;
+ unsigned funcRGB = i915->blend.rgb_func;
+ unsigned srcRGB = i915->blend.rgb_src_factor;
+ unsigned dstRGB = i915->blend.rgb_dst_factor;
LIS6 |= (S6_CBUF_BLEND_ENABLE |
SRC_BLND_FACT(i915_translate_blend_factor(srcRGB)) |
/* I915_NEW_DEPTH
*/
if (i915->depth_test.enabled) {
- GLint func = i915_translate_compare_func(i915->depth_test.func);
+ int func = i915_translate_compare_func(i915->depth_test.func);
LIS6 |= (S6_DEPTH_TEST_ENABLE |
(func << S6_DEPTH_TEST_FUNC_SHIFT));
*/
static void upload_S7( struct i915_context *i915 )
{
- GLfloat LIS7;
+ float LIS7;
/* I915_NEW_SETUP
*/
#ifndef I915_STATE_INLINES_H
#define I915_STATE_INLINES_H
+#include "p_compiler.h"
#include "p_defines.h"
#include "i915_reg.h"
-static INLINE GLboolean i915_validate_vertices( GLuint hw_prim, GLuint nr )
+static INLINE boolean i915_validate_vertices( unsigned hw_prim, unsigned nr )
{
- GLboolean ok;
+ boolean ok;
switch (hw_prim) {
case PRIM3D_POINTLIST:
return ok;
}
-
#endif
#include "i915_context.h"
#include "i915_state.h"
#include "pipe/p_defines.h"
-#include "main/imports.h"
-#include "main/macros.h"
+#include "pipe/p_util.h"
+//#include "main/imports.h"
struct i915_surface
*/
static void
i915_get_tile(struct pipe_surface *ps,
- GLuint x, GLuint y, GLuint w, GLuint h, GLfloat *p)
+ unsigned x, unsigned y, unsigned w, unsigned h, float *p)
{
- const GLuint *src
- = ((const GLuint *) (ps->region->map + ps->offset))
+ const unsigned *src
+ = ((const unsigned *) (ps->region->map + ps->offset))
+ y * ps->region->pitch + x;
- GLuint i, j;
- GLuint w0 = w;
+ unsigned i, j;
+ unsigned w0 = w;
assert(ps->format == PIPE_FORMAT_U_A8_R8_G8_B8);
h = ps->height -y;
#endif
for (i = 0; i < h; i++) {
- GLfloat *pRow = p;
+ float *pRow = p;
for (j = 0; j < w; j++) {
- const GLuint pixel = src[j];
+ const unsigned pixel = src[j];
pRow[0] = UBYTE_TO_FLOAT((pixel >> 16) & 0xff);
pRow[1] = UBYTE_TO_FLOAT((pixel >> 8) & 0xff);
pRow[2] = UBYTE_TO_FLOAT((pixel >> 0) & 0xff);
static void
i915_put_tile(struct pipe_surface *ps,
- GLuint x, GLuint y, GLuint w, GLuint h, const GLfloat *p)
+ unsigned x, unsigned y, unsigned w, unsigned h, const float *p)
{
/* any need to put tiles into i915 surfaces? */
assert(0);
static struct pipe_surface *
-i915_surface_alloc(struct pipe_context *pipe, GLuint format)
+i915_surface_alloc(struct pipe_context *pipe, unsigned format)
{
struct i915_surface *surf = CALLOC_STRUCT(i915_surface);
* Michel Dänzer <michel@tungstengraphics.com>
*/
-#include "macros.h"
+//#include "macros.h"
#include "pipe/p_state.h"
#include "pipe/p_context.h"
+#include "pipe/p_defines.h"
+#include "pipe/p_util.h"
+
#include "i915_tex_layout.h"
+#include "i915_debug.h"
-static GLuint minify( GLuint d )
+static unsigned minify( unsigned d )
{
return MAX2(1, d>>1);
}
static void
i915_miptree_set_level_info(struct pipe_mipmap_tree *mt,
- GLuint level,
- GLuint nr_images,
- GLuint x, GLuint y, GLuint w, GLuint h, GLuint d)
+ unsigned level,
+ unsigned nr_images,
+ unsigned x, unsigned y, unsigned w, unsigned h, unsigned d)
{
- assert(level < MAX_TEXTURE_LEVELS);
+ assert(level < PIPE_MAX_TEXTURE_LEVELS);
mt->level[level].width = w;
mt->level[level].height = h;
assert(nr_images);
assert(!mt->level[level].image_offset);
- mt->level[level].image_offset = (GLuint *) malloc(nr_images * sizeof(GLuint));
+ mt->level[level].image_offset = (unsigned *) malloc(nr_images * sizeof(unsigned));
mt->level[level].image_offset[0] = 0;
}
static void
i915_miptree_set_image_offset(struct pipe_mipmap_tree *mt,
- GLuint level, GLuint img, GLuint x, GLuint y)
+ unsigned level, unsigned img, unsigned x, unsigned y)
{
if (img == 0 && level == 0)
assert(x == 0 && y == 0);
static void
i945_miptree_layout_2d( struct pipe_mipmap_tree *mt )
{
- GLint align_h = 2, align_w = 4;
- GLuint level;
- GLuint x = 0;
- GLuint y = 0;
- GLuint width = mt->width0;
- GLuint height = mt->height0;
+ int align_h = 2, align_w = 4;
+ unsigned level;
+ unsigned x = 0;
+ unsigned y = 0;
+ unsigned width = mt->width0;
+ unsigned height = mt->height0;
mt->pitch = mt->width0;
* 2nd mipmap out past the width of its parent.
*/
if (mt->first_level != mt->last_level) {
- GLuint mip1_width = align(minify(mt->width0), align_w)
+ unsigned mip1_width = align(minify(mt->width0), align_w)
+ minify(minify(mt->width0));
if (mip1_width > mt->width0)
mt->total_height = 0;
for ( level = mt->first_level ; level <= mt->last_level ; level++ ) {
- GLuint img_height;
+ unsigned img_height;
i915_miptree_set_level_info(mt, level, 1, x, y, width, height, 1);
}
-static const GLint initial_offsets[6][2] = {
+static const int initial_offsets[6][2] = {
{0, 0},
{0, 2},
{1, 0},
{1, 3}
};
-static const GLint step_offsets[6][2] = {
+static const int step_offsets[6][2] = {
{0, 2},
{0, 2},
{-1, 2},
};
-GLboolean
+boolean
i915_miptree_layout(struct pipe_context *pipe, struct pipe_mipmap_tree * mt)
{
- GLint level;
+ int level;
switch (mt->target) {
- case GL_TEXTURE_CUBE_MAP:{
- const GLuint dim = mt->width0;
- GLuint face;
- GLuint lvlWidth = mt->width0, lvlHeight = mt->height0;
+ case PIPE_TEXTURE_CUBE: {
+ const unsigned dim = mt->width0;
+ unsigned face;
+ unsigned lvlWidth = mt->width0, lvlHeight = mt->height0;
assert(lvlWidth == lvlHeight); /* cubemap images are square */
}
for (face = 0; face < 6; face++) {
- GLuint x = initial_offsets[face][0] * dim;
- GLuint y = initial_offsets[face][1] * dim;
- GLuint d = dim;
+ unsigned x = initial_offsets[face][0] * dim;
+ unsigned y = initial_offsets[face][1] * dim;
+ unsigned d = dim;
for (level = mt->first_level; level <= mt->last_level; level++) {
i915_miptree_set_image_offset(mt, level, face, x, y);
-
- if (d == 0)
- _mesa_printf("cube mipmap %d/%d (%d..%d) is 0x0\n",
- face, level, mt->first_level, mt->last_level);
-
d >>= 1;
x += step_offsets[face][0] * d;
y += step_offsets[face][1] * d;
}
break;
}
- case GL_TEXTURE_3D:{
- GLuint width = mt->width0;
- GLuint height = mt->height0;
- GLuint depth = mt->depth0;
- GLuint stack_height = 0;
+ case PIPE_TEXTURE_3D:{
+ unsigned width = mt->width0;
+ unsigned height = mt->height0;
+ unsigned depth = mt->depth0;
+ unsigned stack_height = 0;
/* Calculate the size of a single slice.
*/
*/
depth = mt->depth0;
for (level = mt->first_level; level <= mt->last_level; level++) {
- GLuint i;
+ unsigned i;
for (i = 0; i < depth; i++)
i915_miptree_set_image_offset(mt, level, i,
0, i * stack_height);
}
default:{
- GLuint width = mt->width0;
- GLuint height = mt->height0;
- GLuint img_height;
+ unsigned width = mt->width0;
+ unsigned height = mt->height0;
+ unsigned img_height;
mt->pitch = ((mt->width0 * mt->cpp + 3) & ~3) / mt->cpp;
mt->total_height = 0;
mt->total_height, mt->cpp, mt->pitch * mt->total_height * mt->cpp);
*/
- return GL_TRUE;
+ return TRUE;
}
-GLboolean
+boolean
i945_miptree_layout(struct pipe_context *pipe, struct pipe_mipmap_tree * mt)
{
- GLint level;
+ int level;
switch (mt->target) {
- case GL_TEXTURE_CUBE_MAP:{
- const GLuint dim = mt->width0;
- GLuint face;
- GLuint lvlWidth = mt->width0, lvlHeight = mt->height0;
+ case PIPE_TEXTURE_CUBE:{
+ const unsigned dim = mt->width0;
+ unsigned face;
+ unsigned lvlWidth = mt->width0, lvlHeight = mt->height0;
assert(lvlWidth == lvlHeight); /* cubemap images are square */
for (face = 0; face < 6; face++) {
- GLuint x = initial_offsets[face][0] * dim;
- GLuint y = initial_offsets[face][1] * dim;
- GLuint d = dim;
+ unsigned x = initial_offsets[face][0] * dim;
+ unsigned y = initial_offsets[face][1] * dim;
+ unsigned d = dim;
if (dim == 4 && face >= 4) {
y = mt->total_height - 4;
switch (d) {
case 4:
switch (face) {
- case FACE_POS_X:
- case FACE_NEG_X:
+ case PIPE_TEX_FACE_POS_X:
+ case PIPE_TEX_FACE_NEG_X:
x += step_offsets[face][0] * d;
y += step_offsets[face][1] * d;
break;
- case FACE_POS_Y:
- case FACE_NEG_Y:
+ case PIPE_TEX_FACE_POS_Y:
+ case PIPE_TEX_FACE_NEG_Y:
y += 12;
x -= 8;
break;
- case FACE_POS_Z:
- case FACE_NEG_Z:
+ case PIPE_TEX_FACE_POS_Z:
+ case PIPE_TEX_FACE_NEG_Z:
y = mt->total_height - 4;
x = (face - 4) * 8;
break;
}
break;
}
- case GL_TEXTURE_3D:{
- GLuint width = mt->width0;
- GLuint height = mt->height0;
- GLuint depth = mt->depth0;
- GLuint pack_x_pitch, pack_x_nr;
- GLuint pack_y_pitch;
- GLuint level;
+ case PIPE_TEXTURE_3D:{
+ unsigned width = mt->width0;
+ unsigned height = mt->height0;
+ unsigned depth = mt->depth0;
+ unsigned pack_x_pitch, pack_x_nr;
+ unsigned pack_y_pitch;
+ unsigned level;
mt->pitch = ((mt->width0 * mt->cpp + 3) & ~3) / mt->cpp;
mt->total_height = 0;
pack_x_nr = 1;
for (level = mt->first_level; level <= mt->last_level; level++) {
- GLuint nr_images = mt->target == GL_TEXTURE_3D ? depth : 6;
- GLint x = 0;
- GLint y = 0;
- GLint q, j;
+ unsigned nr_images = mt->target == PIPE_TEXTURE_3D ? depth : 6;
+ int x = 0;
+ int y = 0;
+ int q, j;
i915_miptree_set_level_info(mt, level, nr_images,
0, mt->total_height,
break;
}
- case GL_TEXTURE_1D:
- case GL_TEXTURE_2D:
- case GL_TEXTURE_RECTANGLE_ARB:
+ case PIPE_TEXTURE_1D:
+ case PIPE_TEXTURE_2D:
+// case PIPE_TEXTURE_RECTANGLE:
i945_miptree_layout_2d(mt);
break;
default:
- _mesa_problem(NULL, "Unexpected tex target in i945_miptree_layout()");
+ assert(0);
+ return FALSE;
}
/*
mt->total_height, mt->cpp, mt->pitch * mt->total_height * mt->cpp);
*/
- return GL_TRUE;
+ return TRUE;
}
struct pipe_mipmap_tree;
-extern GLboolean
+extern boolean
i915_miptree_layout(struct pipe_context *, struct pipe_mipmap_tree *);
-extern GLboolean
+extern boolean
i945_miptree_layout(struct pipe_context *, struct pipe_mipmap_tree *);
#ifndef I915_WINSYS_H
#define I915_WINSYS_H
-#include "main/mtypes.h"
+//#include "main/mtypes.h"
/* This is the interface that softpipe requires any window system
* hosting it to implement. This is the only include file in softpipe
#ifndef PIPE_CONTEXT_H
#define PIPE_CONTEXT_H
-#include "main/mtypes.h"
+//#include "main/mtypes.h"
#include "p_state.h"
+#include "p_compiler.h"
/* Drawing currently kludged up via the existing tnl/ module.
/*
* Queries
*/
- const GLuint *(*supported_formats)(struct pipe_context *pipe,
- GLuint *numFormats);
+ const unsigned *(*supported_formats)(struct pipe_context *pipe,
+ unsigned *numFormats);
void (*max_texture_size)(struct pipe_context *pipe,
- GLuint textureType, /* PIPE_TEXTURE_x */
- GLuint *maxWidth,
- GLuint *maxHeight,
- GLuint *maxDepth);
+ unsigned textureType, /* PIPE_TEXTURE_x */
+ unsigned *maxWidth,
+ unsigned *maxHeight,
+ unsigned *maxDepth);
const char *(*get_name)( struct pipe_context *pipe );
struct vertex_buffer *VB );
void (*draw_vertices)( struct pipe_context *pipe,
- GLuint mode,
- GLuint numVertex, const GLfloat *verts,
- GLuint numAttribs, const GLuint attribs[]);
+ unsigned mode,
+ unsigned numVertex, const float *verts,
+ unsigned numAttribs, const unsigned attribs[]);
/** Clear a surface to given value (no scissor; clear whole surface) */
void (*clear)(struct pipe_context *pipe, struct pipe_surface *ps,
- GLuint clearValue);
+ unsigned clearValue);
/** occlusion counting (XXX this may be temporary - we should probably
* have generic query objects with begin/end methods)
*/
void (*reset_occlusion_counter)(struct pipe_context *pipe);
- GLuint (*get_occlusion_counter)(struct pipe_context *pipe);
+ unsigned (*get_occlusion_counter)(struct pipe_context *pipe);
/*
* State functions
const struct pipe_stencil_state * );
void (*set_sampler_state)( struct pipe_context *,
- GLuint unit,
+ unsigned unit,
const struct pipe_sampler_state * );
void (*set_texture_state)( struct pipe_context *,
- GLuint unit,
+ unsigned unit,
struct pipe_mipmap_tree * );
void (*set_viewport_state)( struct pipe_context *,
* This might go away...
*/
struct pipe_surface *(*surface_alloc)(struct pipe_context *pipe,
- GLuint format);
+ unsigned format);
struct pipe_surface *(*get_tex_surface)(struct pipe_context *pipe,
struct pipe_mipmap_tree *texture,
- GLuint face, GLuint level,
- GLuint zslice);
+ unsigned face, unsigned level,
+ unsigned zslice);
/*
* Memory region functions
* Some of these may go away...
*/
struct pipe_region *(*region_alloc)(struct pipe_context *pipe,
- GLuint cpp, GLuint width, GLuint height,
- GLbitfield flags);
+ unsigned cpp, unsigned width, unsigned height,
+ unsigned flags);
void (*region_release)(struct pipe_context *pipe, struct pipe_region **r);
void (*region_idle)(struct pipe_context *pipe, struct pipe_region *region);
- GLubyte *(*region_map)(struct pipe_context *pipe, struct pipe_region *r);
+ ubyte *(*region_map)(struct pipe_context *pipe, struct pipe_region *r);
void (*region_unmap)(struct pipe_context *pipe, struct pipe_region *r);
void (*region_data)(struct pipe_context *pipe,
struct pipe_region *dest,
- GLuint dest_offset,
- GLuint destx, GLuint desty,
- const void *src, GLuint src_stride,
- GLuint srcx, GLuint srcy, GLuint width, GLuint height);
+ unsigned dest_offset,
+ unsigned destx, unsigned desty,
+ const void *src, unsigned src_stride,
+ unsigned srcx, unsigned srcy, unsigned width, unsigned height);
void (*region_copy)(struct pipe_context *pipe,
struct pipe_region *dest,
- GLuint dest_offset,
- GLuint destx, GLuint desty,
+ unsigned dest_offset,
+ unsigned destx, unsigned desty,
struct pipe_region *src, /* don't make this const -
need to map/unmap */
- GLuint src_offset,
- GLuint srcx, GLuint srcy, GLuint width, GLuint height);
+ unsigned src_offset,
+ unsigned srcx, unsigned srcy, unsigned width, unsigned height);
void (*region_fill)(struct pipe_context *pipe,
struct pipe_region *dst,
- GLuint dst_offset,
- GLuint dstx, GLuint dsty,
- GLuint width, GLuint height,
- GLuint value);
+ unsigned dst_offset,
+ unsigned dstx, unsigned dsty,
+ unsigned width, unsigned height,
+ unsigned value);
/*
* Texture functions
*/
- GLboolean (*mipmap_tree_layout)( struct pipe_context *pipe,
- struct pipe_mipmap_tree *mt );
+ boolean (*mipmap_tree_layout)( struct pipe_context *pipe,
+ struct pipe_mipmap_tree *mt );
/* Flush rendering:
#define PIPE_TEX_COMPARE_NONE 0
#define PIPE_TEX_COMPARE_R_TO_TEXTURE 1
+#define PIPE_TEX_FACE_POS_X 0
+#define PIPE_TEX_FACE_NEG_X 1
+#define PIPE_TEX_FACE_POS_Y 2
+#define PIPE_TEX_FACE_NEG_Y 3
+#define PIPE_TEX_FACE_POS_Z 4
+#define PIPE_TEX_FACE_NEG_Z 5
+#define PIPE_TEX_FACE_MAX 6
+
/**
* Texture/surface image formats (preliminary)
#define PIPE_FLUSH_RENDER_CACHE 0x1
#define PIPE_FLUSH_TEXTURE_CACHE 0x2
+
+
#endif
#ifndef PIPE_STATE_H
#define PIPE_STATE_H
-#include "mtypes.h"
-
-
+#include "p_compiler.h"
/**
* Implementation limits
#define PIPE_MAX_CONSTANT 32
#define PIPE_ATTRIB_MAX 32
#define PIPE_MAX_COLOR_BUFS 8
+#define PIPE_MAX_TEXTURE_LEVELS 16
/* fwd decl */
*/
struct pipe_setup_state
{
- GLuint flatshade:1;
- GLuint light_twoside:1;
-
- GLuint front_winding:2; /**< PIPE_WINDING_x */
-
- GLuint cull_mode:2; /**< PIPE_WINDING_x */
-
- GLuint fill_cw:2; /**< PIPE_POLYGON_MODE_x */
- GLuint fill_ccw:2; /**< PIPE_POLYGON_MODE_x */
-
- GLuint offset_cw:1;
- GLuint offset_ccw:1;
-
- GLuint scissor:1;
-
- GLuint poly_smooth:1;
- GLuint poly_stipple_enable:1;
-
- GLuint line_smooth:1;
- GLuint line_stipple_enable:1;
-
- GLuint point_smooth:1;
-
- GLuint multisample:1; /* XXX maybe more ms state in future */
-
- GLubyte line_stipple_factor; /**< [1..256] actually */
- GLushort line_stipple_pattern;
- GLfloat line_width;
- GLfloat point_size; /**< used when no per-vertex size */
- GLfloat offset_units;
- GLfloat offset_scale;
+ unsigned flatshade:1;
+ unsigned light_twoside:1;
+ unsigned front_winding:2; /**< PIPE_WINDING_x */
+ unsigned cull_mode:2; /**< PIPE_WINDING_x */
+ unsigned fill_cw:2; /**< PIPE_POLYGON_MODE_x */
+ unsigned fill_ccw:2; /**< PIPE_POLYGON_MODE_x */
+ unsigned offset_cw:1;
+ unsigned offset_ccw:1;
+ unsigned scissor:1;
+ unsigned poly_smooth:1;
+ unsigned poly_stipple_enable:1;
+ unsigned point_smooth:1;
+ unsigned multisample:1; /* XXX maybe more ms state in future */
+ unsigned line_smooth:1;
+ unsigned line_stipple_enable:1;
+ unsigned line_stipple_factor:8; /**< [1..256] actually */
+ unsigned line_stipple_pattern:16;
+
+ float line_width;
+ float point_size; /**< used when no per-vertex size */
+ float offset_units;
+ float offset_scale;
};
struct pipe_poly_stipple {
- GLuint stipple[32];
+ unsigned stipple[32];
};
struct pipe_viewport_state {
- GLfloat scale[4];
- GLfloat translate[4];
+ float scale[4];
+ float translate[4];
};
struct pipe_scissor_state {
- GLshort minx;
- GLshort miny;
- GLshort maxx;
- GLshort maxy;
+ unsigned minx:16;
+ unsigned miny:16;
+ unsigned maxx:16;
+ unsigned maxy:16;
};
struct pipe_clip_state {
- GLfloat ucp[PIPE_MAX_CLIP_PLANES][4];
- GLuint nr;
+ float ucp[PIPE_MAX_CLIP_PLANES][4];
+ unsigned nr;
};
struct pipe_constant_buffer {
- GLfloat constant[PIPE_MAX_CONSTANT][4];
- GLuint nr_constants;
+ float constant[PIPE_MAX_CONSTANT][4];
+ unsigned nr_constants;
};
struct pipe_fs_state {
- GLbitfield inputs_read; /* FRAG_ATTRIB_* */
+ unsigned inputs_read; /* FRAG_ATTRIB_* */
const struct tgsi_token *tokens;
struct pipe_constant_buffer *constants; /* XXX temporary? */
};
struct pipe_depth_state
{
- GLuint enabled:1; /**< depth test enabled? */
- GLuint writemask:1; /**< allow depth buffer writes? */
- GLuint func:3; /**< depth test func (PIPE_FUNC_x) */
- GLuint occlusion_count:1; /**< XXX move this elsewhere? */
- GLfloat clear; /**< Clear value in [0,1] (XXX correct place?) */
+ unsigned enabled:1; /**< depth test enabled? */
+ unsigned writemask:1; /**< allow depth buffer writes? */
+ unsigned func:3; /**< depth test func (PIPE_FUNC_x) */
+ unsigned occlusion_count:1; /**< XXX move this elsewhere? */
+ float clear; /**< Clear value in [0,1] (XXX correct place?) */
};
struct pipe_alpha_test_state {
- GLuint enabled:1;
- GLuint func:3; /**< PIPE_FUNC_x */
- GLfloat ref; /**< reference value */
+ unsigned enabled:1;
+ unsigned func:3; /**< PIPE_FUNC_x */
+ float ref; /**< reference value */
};
struct pipe_blend_state {
- GLuint blend_enable:1;
+ unsigned blend_enable:1;
- GLuint rgb_func:3; /**< PIPE_BLEND_x */
- GLuint rgb_src_factor:5; /**< PIPE_BLENDFACTOR_x */
- GLuint rgb_dst_factor:5; /**< PIPE_BLENDFACTOR_x */
+ unsigned rgb_func:3; /**< PIPE_BLEND_x */
+ unsigned rgb_src_factor:5; /**< PIPE_BLENDFACTOR_x */
+ unsigned rgb_dst_factor:5; /**< PIPE_BLENDFACTOR_x */
- GLuint alpha_func:3; /**< PIPE_BLEND_x */
- GLuint alpha_src_factor:5; /**< PIPE_BLENDFACTOR_x */
- GLuint alpha_dst_factor:5; /**< PIPE_BLENDFACTOR_x */
+ unsigned alpha_func:3; /**< PIPE_BLEND_x */
+ unsigned alpha_src_factor:5; /**< PIPE_BLENDFACTOR_x */
+ unsigned alpha_dst_factor:5; /**< PIPE_BLENDFACTOR_x */
- GLuint logicop_enable:1;
- GLuint logicop_func:4; /**< PIPE_LOGICOP_x */
+ unsigned logicop_enable:1;
+ unsigned logicop_func:4; /**< PIPE_LOGICOP_x */
- GLuint colormask:4; /**< bitmask of PIPE_MASK_R/G/B/A */
- GLuint dither:1;
+ unsigned colormask:4; /**< bitmask of PIPE_MASK_R/G/B/A */
+ unsigned dither:1;
};
struct pipe_blend_color {
- GLfloat color[4];
+ float color[4];
};
struct pipe_clear_color_state
{
- GLfloat color[4];
+ float color[4];
};
struct pipe_stencil_state {
- GLuint front_enabled:1;
- GLuint front_func:3; /**< PIPE_FUNC_x */
- GLuint front_fail_op:3; /**< PIPE_STENCIL_OP_x */
- GLuint front_zpass_op:3; /**< PIPE_STENCIL_OP_x */
- GLuint front_zfail_op:3; /**< PIPE_STENCIL_OP_x */
- GLuint back_enabled:1;
- GLuint back_func:3; /**< PIPE_FUNC_x */
- GLuint back_fail_op:3; /**< PIPE_STENCIL_OP_x */
- GLuint back_zpass_op:3; /**< PIPE_STENCIL_OP_x */
- GLuint back_zfail_op:3; /**< PIPE_STENCIL_OP_x */
- GLubyte ref_value[2]; /**< [0] = front, [1] = back */
- GLubyte value_mask[2];
- GLubyte write_mask[2];
- GLubyte clear_value;
+ unsigned front_enabled:1;
+ unsigned front_func:3; /**< PIPE_FUNC_x */
+ unsigned front_fail_op:3; /**< PIPE_STENCIL_OP_x */
+ unsigned front_zpass_op:3; /**< PIPE_STENCIL_OP_x */
+ unsigned front_zfail_op:3; /**< PIPE_STENCIL_OP_x */
+ unsigned back_enabled:1;
+ unsigned back_func:3; /**< PIPE_FUNC_x */
+ unsigned back_fail_op:3; /**< PIPE_STENCIL_OP_x */
+ unsigned back_zpass_op:3; /**< PIPE_STENCIL_OP_x */
+ unsigned back_zfail_op:3; /**< PIPE_STENCIL_OP_x */
+ ubyte ref_value[2]; /**< [0] = front, [1] = back */
+ ubyte value_mask[2];
+ ubyte write_mask[2];
+ ubyte clear_value;
};
struct pipe_framebuffer_state
{
/** multiple colorbuffers for multiple render targets */
- GLuint num_cbufs;
+ unsigned num_cbufs;
struct pipe_surface *cbufs[PIPE_MAX_COLOR_BUFS];
struct pipe_surface *zbuf; /**< Z buffer */
*/
struct pipe_sampler_state
{
- GLuint wrap_s:3; /**< PIPE_TEX_WRAP_x */
- GLuint wrap_t:3; /**< PIPE_TEX_WRAP_x */
- GLuint wrap_r:3; /**< PIPE_TEX_WRAP_x */
- GLuint min_img_filter:2; /**< PIPE_TEX_FILTER_x */
- GLuint min_mip_filter:2; /**< PIPE_TEX_MIPFILTER_x */
- GLuint mag_img_filter:2; /**< PIPE_TEX_FILTER_x */
- GLuint compare:1; /**< shadow/depth compare enabled? */
- GLenum compare_mode:1; /**< PIPE_TEX_COMPARE_x */
- GLenum compare_func:3; /**< PIPE_FUNC_x */
- GLfloat shadow_ambient; /**< shadow test fail color/intensity */
- GLfloat min_lod;
- GLfloat max_lod;
- GLfloat lod_bias;
+ unsigned wrap_s:3; /**< PIPE_TEX_WRAP_x */
+ unsigned wrap_t:3; /**< PIPE_TEX_WRAP_x */
+ unsigned wrap_r:3; /**< PIPE_TEX_WRAP_x */
+ unsigned min_img_filter:2; /**< PIPE_TEX_FILTER_x */
+ unsigned min_mip_filter:2; /**< PIPE_TEX_MIPFILTER_x */
+ unsigned mag_img_filter:2; /**< PIPE_TEX_FILTER_x */
+ unsigned compare:1; /**< shadow/depth compare enabled? */
+ unsigned compare_mode:1; /**< PIPE_TEX_COMPARE_x */
+ unsigned compare_func:3; /**< PIPE_FUNC_x */
+ float shadow_ambient; /**< shadow test fail color/intensity */
+ float min_lod;
+ float max_lod;
+ float lod_bias;
#if 0 /* need these? */
- GLint BaseLevel; /**< min mipmap level, OpenGL 1.2 */
- GLint MaxLevel; /**< max mipmap level, OpenGL 1.2 */
- GLfloat border_color[4];
+ int BaseLevel; /**< min mipmap level, OpenGL 1.2 */
+ int MaxLevel; /**< max mipmap level, OpenGL 1.2 */
+ float border_color[4];
#endif
- GLfloat max_anisotropy;
+ float max_anisotropy;
};
{
struct pipe_buffer_handle *buffer; /**< driver private buffer handle */
- GLuint refcount; /**< Reference count for region */
- GLuint cpp; /**< bytes per pixel */
- GLuint pitch; /**< in pixels */
- GLuint height; /**< in pixels */
- GLubyte *map; /**< only non-NULL when region is actually mapped */
- GLuint map_refcount; /**< Reference count for mapping */
+ unsigned refcount; /**< Reference count for region */
+ unsigned cpp; /**< bytes per pixel */
+ unsigned pitch; /**< in pixels */
+ unsigned height; /**< in pixels */
+ ubyte *map; /**< only non-NULL when region is actually mapped */
+ unsigned map_refcount; /**< Reference count for mapping */
};
struct pipe_surface
{
struct pipe_region *region;
- GLuint format:5; /**< PIPE_FORMAT_x */
- GLuint width, height;
- GLuint offset; /**< offset from start of region, in bytes */
- GLint refcount;
+ unsigned format:5; /**< PIPE_FORMAT_x */
+ unsigned width, height;
+ unsigned offset; /**< offset from start of region, in bytes */
+ unsigned refcount;
/** get block/tile of pixels from surface */
void (*get_tile)(struct pipe_surface *ps,
- GLuint x, GLuint y, GLuint w, GLuint h, GLfloat *p);
+ unsigned x, unsigned y, unsigned w, unsigned h, float *p);
/** put block/tile of pixels into surface */
void (*put_tile)(struct pipe_surface *ps,
- GLuint x, GLuint y, GLuint w, GLuint h, const GLfloat *p);
+ unsigned x, unsigned y, unsigned w, unsigned h, const float *p);
};
*/
struct pipe_mipmap_level
{
- GLuint level_offset;
- GLuint width;
- GLuint height;
- GLuint depth;
- GLuint nr_images;
+ unsigned level_offset;
+ unsigned width;
+ unsigned height;
+ unsigned depth;
+ unsigned nr_images;
/* Explicitly store the offset of each image for each cube face or
* depth value. Pretty much have to accept that hardware formats
* compute the offsets of depth/cube images within a mipmap level,
* so have to store them as a lookup table:
*/
- GLuint *image_offset; /**< array [depth] of offsets */
+ unsigned *image_offset; /**< array [depth] of offsets */
};
struct pipe_mipmap_tree
{
/* Effectively the key:
*/
- GLenum target; /* XXX convert to PIPE_TEXTURE_x */
- GLenum internal_format; /* XXX convert to PIPE_FORMAT_x */
+ unsigned target; /* XXX convert to PIPE_TEXTURE_x */
+ unsigned internal_format; /* XXX convert to PIPE_FORMAT_x */
+
+ unsigned format; /**< PIPE_FORMAT_x */
+ unsigned first_level;
+ unsigned last_level;
- GLuint format; /**< PIPE_FORMAT_x */
- GLuint first_level;
- GLuint last_level;
+ unsigned width0, height0, depth0; /**< Level zero image dimensions */
+ unsigned cpp;
- GLuint width0, height0, depth0; /**< Level zero image dimensions */
- GLuint cpp;
- GLboolean compressed;
+ unsigned compressed:1;
/* Derived from the above:
*/
- GLuint pitch;
- GLuint depth_pitch; /* per-image on i945? */
- GLuint total_height;
+ unsigned pitch;
+ unsigned depth_pitch; /* per-image on i945? */
+ unsigned total_height;
/* Includes image offset tables:
*/
- struct pipe_mipmap_level level[MAX_TEXTURE_LEVELS];
+ struct pipe_mipmap_level level[PIPE_MAX_TEXTURE_LEVELS];
/* The data is held here:
*/
/* These are also refcounted:
*/
- GLuint refcount;
+ unsigned refcount;
};
*/
void
softpipe_clear(struct pipe_context *pipe, struct pipe_surface *ps,
- GLuint clearValue)
+ unsigned clearValue)
{
struct softpipe_context *softpipe = softpipe_context(pipe);
GLint x, y, w, h;
extern void
softpipe_clear(struct pipe_context *pipe, struct pipe_surface *ps,
- GLuint clearValue);
+ unsigned clearValue);
#endif /* SP_CLEAR_H */
* all the enabled attributes run contiguously.
*/
-#include "glheader.h"
-#include "imports.h"
+#include "main/mtypes.h"
+
+#include "pipe/p_util.h"
+#include "tgsi/core/tgsi_core.h"
+
#include "sp_context.h"
#include "sp_headers.h"
#include "sp_quad.h"
#include "sp_tex_sample.h"
-#include "tgsi/core/tgsi_core.h"
#if 0
#if defined __GNUC__
const struct setup_coefficient *coef; /**< will point to quad->coef */
#if ALIGNED_ATTRIBS
- GLfloat attr[FRAG_ATTRIB_MAX][NUM_CHANNELS][QUAD_SIZE] __attribute__(( aligned( 16 ) ));
+ GLfloat attr[PIPE_ATTRIB_MAX][NUM_CHANNELS][QUAD_SIZE] __attribute__(( aligned( 16 ) ));
#else
- GLfloat attr[FRAG_ATTRIB_MAX][NUM_CHANNELS][QUAD_SIZE];
+ GLfloat attr[PIPE_ATTRIB_MAX][NUM_CHANNELS][QUAD_SIZE];
#endif
};
#include "macros.h"
#include "pipe/p_state.h"
#include "pipe/p_context.h"
+#include "pipe/p_defines.h"
#include "sp_tex_layout.h"
switch (d) {
case 4:
switch (face) {
- case FACE_POS_X:
- case FACE_NEG_X:
+ case PIPE_TEX_FACE_POS_X:
+ case PIPE_TEX_FACE_NEG_X:
x += step_offsets[face][0] * d;
y += step_offsets[face][1] * d;
break;
- case FACE_POS_Y:
- case FACE_NEG_Y:
+ case PIPE_TEX_FACE_POS_Y:
+ case PIPE_TEX_FACE_NEG_Y:
y += 12;
x -= 8;
break;
- case FACE_POS_Z:
- case FACE_NEG_Z:
+ case PIPE_TEX_FACE_POS_Z:
+ case PIPE_TEX_FACE_NEG_Z:
y = mt->total_height - 4;
x = (face - 4) * 8;
break;
projects / mesa.git / commitdiff