Commit aa133069 authored by Eric Anholt's avatar Eric Anholt Committed by Zhigang Gong

glamor: Start adding render acceleration support.

This brings in idr's glu3 code.  We'll probably want to move to linking to
it as a library, once an ABI-stable release is out.
parent 4a51cc04
......@@ -2147,6 +2147,7 @@ Xi/Makefile
xfixes/Makefile
exa/Makefile
glamor/Makefile
glamor/glu3/Makefile
hw/Makefile
hw/xfree86/Makefile
hw/xfree86/common/Makefile
......
......@@ -4,6 +4,8 @@ noinst_LTLIBRARIES = libglamor.la
# built (in hw/xfree86/os-support/solaris) until after glamor is built
SOLARIS_ASM_CFLAGS=""
SUBDIRS = glu3
if XORG
sdk_HEADERS = glamor.h
endif
......@@ -24,3 +26,5 @@ libglamor_la_SOURCES = \
glamor_render.c \
glamor_tile.c \
glamor.h
libglamor_la_LIBADD = \
glu3/libglu3.la
......@@ -208,6 +208,7 @@ glamor_init(ScreenPtr screen)
glamor_init_solid_shader(screen);
glamor_init_tile_shader(screen);
glamor_init_composite_shaders(screen);
return TRUE;
......
......@@ -38,6 +38,13 @@ typedef struct glamor_transform_uniforms {
GLint y_scale;
} glamor_transform_uniforms;
typedef struct glamor_composite_shader {
GLuint prog;
GLint dest_to_dest_uniform_location;
GLint dest_to_source_uniform_location;
GLint dest_to_mask_uniform_location;
} glamor_composite_shader;
typedef struct glamor_screen_private {
CreateGCProcPtr saved_create_gc;
CreatePixmapProcPtr saved_create_pixmap;
......@@ -52,8 +59,12 @@ typedef struct glamor_screen_private {
GLint solid_color_uniform_location;
glamor_transform_uniforms solid_transform;
/* glamor_tile */
GLint tile_prog;
glamor_transform_uniforms tile_transform;
/* glamor_composite */
glamor_composite_shader composite_shader[2];
} glamor_screen_private;
typedef struct glamor_pixmap_private {
......@@ -75,6 +86,10 @@ glamor_get_pixmap_private(PixmapPtr pixmap)
return dixLookupPrivate(&pixmap->devPrivates, glamor_pixmap_private_key);
}
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
#define ALIGN(i,m) (((i) + (m) - 1) & ~((m) - 1))
#define MIN(a,b) ((a) < (b) ? (a) : (b))
/**
* Returns TRUE if the given planemask covers all the significant bits in the
* pixel values for pDrawable.
......@@ -166,6 +181,7 @@ void glamor_trapezoids(CARD8 op,
PicturePtr src, PicturePtr dst,
PictFormatPtr mask_format, INT16 x_src, INT16 y_src,
int ntrap, xTrapezoid *traps);
void glamor_init_composite_shaders(ScreenPtr screen);
/* glamor_tile.c */
void glamor_tile(PixmapPtr pixmap, PixmapPtr tile,
......
This diff is collapsed.
noinst_LTLIBRARIES = libglu3.la
# Override these since glu3 doesn't need them and the needed files aren't
# built (in hw/xfree86/os-support/solaris) until after glu3 is built
SOLARIS_ASM_CFLAGS=""
INCLUDES = \
$(XORG_INCS)
AM_CFLAGS = $(XORG_CFLAGS) $(DIX_CFLAGS)
libglu3_la_SOURCES = \
matrix.c \
glu3.h \
glu3_scalar.h
/*
* Copyright © 2009 Ian D. Romanick
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#ifndef __glu3_h__
#define __glu3_h__
#include <GL/gl.h>
#define GLU_VERSION_3_0
struct GLUmat4;
struct GLUvec4 {
GLfloat values[4];
#ifdef __cplusplus
inline GLUvec4(void)
{
}
inline GLUvec4(GLfloat x , GLfloat y, GLfloat z, GLfloat w)
{
values[0] = x;
values[1] = y;
values[2] = z;
values[3] = w;
}
inline GLUvec4(const GLUvec4 &v)
{
values[0] = v.values[0];
values[1] = v.values[1];
values[2] = v.values[2];
values[3] = v.values[3];
}
GLUvec4 operator *(const GLUmat4 &) const;
GLUvec4 operator *(const GLUvec4 &) const;
GLUvec4 operator *(GLfloat) const;
GLUvec4 operator +(const GLUvec4 &) const;
GLUvec4 operator -(const GLUvec4 &) const;
#endif /* __cplusplus */
};
struct GLUmat4 {
struct GLUvec4 col[4];
#ifdef __cplusplus
inline GLUmat4(void)
{
}
inline GLUmat4(const GLUvec4 & c0, const GLUvec4 & c1,
const GLUvec4 & c2, const GLUvec4 & c3)
{
col[0] = c0;
col[1] = c1;
col[2] = c2;
col[3] = c3;
}
inline GLUmat4(const GLUmat4 &m)
{
col[0] = m.col[0];
col[1] = m.col[1];
col[2] = m.col[2];
col[3] = m.col[3];
}
GLUvec4 operator *(const GLUvec4 &) const;
GLUmat4 operator *(const GLUmat4 &) const;
GLUmat4 operator *(GLfloat) const;
GLUmat4 operator +(const GLUmat4 &) const;
GLUmat4 operator -(const GLUmat4 &) const;
#endif /* __cplusplus */
};
#define GLU_MAX_STACK_DEPTH 32
struct GLUmat4Stack {
struct GLUmat4 stack[GLU_MAX_STACK_DEPTH];
unsigned top;
#ifdef __cplusplus
GLUmat4Stack() : top(0)
{
/* empty */
}
#endif /* __cplusplus */
};
#ifndef __cplusplus
typedef struct GLUvec4 GLUvec4;
typedef struct GLUmat4 GLUmat4;
typedef struct GLUmat4Stack GLUmat4Stack;
#endif /* __cplusplus */
#ifdef __cplusplus
extern "C" {
#endif
GLfloat gluDot4_4v(const GLUvec4 *, const GLUvec4 *);
GLfloat gluDot3_4v(const GLUvec4 *, const GLUvec4 *);
GLfloat gluDot2_4v(const GLUvec4 *, const GLUvec4 *);
void gluCross4v(GLUvec4 *result, const GLUvec4 *, const GLUvec4 *);
void gluNormalize4v(GLUvec4 *result, const GLUvec4 *);
GLfloat gluLength4v(const GLUvec4 *);
GLfloat gluLengthSqr4v(const GLUvec4 *);
void gluOuter4v(GLUmat4 *result, const GLUvec4 *, const GLUvec4 *);
void gluMult4v_4v(GLUvec4 *result, const GLUvec4 *, const GLUvec4 *);
void gluDiv4v_4v(GLUvec4 *result, const GLUvec4 *, const GLUvec4 *);
void gluAdd4v_4v(GLUvec4 *result, const GLUvec4 *, const GLUvec4 *);
void gluSub4v_4v(GLUvec4 *result, const GLUvec4 *, const GLUvec4 *);
void gluMult4v_f(GLUvec4 *result, const GLUvec4 *, GLfloat);
void gluDiv4v_f(GLUvec4 *result, const GLUvec4 *, GLfloat);
void gluAdd4v_f(GLUvec4 *result, const GLUvec4 *, GLfloat);
void gluSub4v_f(GLUvec4 *result, const GLUvec4 *, GLfloat);
void gluMult4m_4m(GLUmat4 *result, const GLUmat4 *, const GLUmat4 *);
void gluAdd4m_4m(GLUmat4 *result, const GLUmat4 *, const GLUmat4 *);
void gluSub4m_4m(GLUmat4 *result, const GLUmat4 *, const GLUmat4 *);
void gluMult4m_4v(GLUvec4 *result, const GLUmat4 *m, const GLUvec4 *v);
void gluMult4m_f(GLUmat4 *result, const GLUmat4 *, GLfloat);
void gluScale4v(GLUmat4 *result, const GLUvec4 *);
void gluTranslate3f(GLUmat4 *result, GLfloat x, GLfloat y, GLfloat z);
void gluTranslate4v(GLUmat4 *result, const GLUvec4 *);
void gluRotate4v(GLUmat4 *result, const GLUvec4 *axis, GLfloat angle);
void gluLookAt4v(GLUmat4 *result, const GLUvec4 *eye, const GLUvec4 *center,
const GLUvec4 *up);
void gluPerspective4f(GLUmat4 *result, GLfloat fovy, GLfloat aspect,
GLfloat near, GLfloat far);
void gluTranspose4m(GLUmat4 *result, const GLUmat4 *m);
void gluFrustum6f(GLUmat4 *result,
GLfloat left, GLfloat right,
GLfloat bottom, GLfloat top,
GLfloat near, GLfloat far);
void gluOrtho6f(GLUmat4 *result,
GLfloat left, GLfloat right,
GLfloat bottom, GLfloat top,
GLfloat near, GLfloat far);
extern const GLUmat4 gluIdentityMatrix;
#ifdef __cplusplus
};
#endif
#ifdef __cplusplus
GLfloat gluDot4(const GLUvec4 &, const GLUvec4 &);
GLfloat gluDot3(const GLUvec4 &, const GLUvec4 &);
GLfloat gluDot2(const GLUvec4 &, const GLUvec4 &);
GLUvec4 gluCross(const GLUvec4 &, const GLUvec4 &);
GLUvec4 gluNormalize(const GLUvec4 &);
GLfloat gluLength(const GLUvec4 &);
GLfloat gluLengthSqr(const GLUvec4 &);
#endif /* __cplusplus */
#include "glu3_scalar.h"
#endif /* __glu3_h__ */
/*
* Copyright © 2009 Ian D. Romanick
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include <math.h>
#include <string.h>
extern inline void gluMult4v_4v(GLUvec4 *result,
const GLUvec4 *v1, const GLUvec4 *v2)
{
result->values[0] = v1->values[0] * v2->values[0];
result->values[1] = v1->values[1] * v2->values[1];
result->values[2] = v1->values[2] * v2->values[2];
result->values[3] = v1->values[3] * v2->values[3];
}
extern inline void gluDiv4v_4v(GLUvec4 *result,
const GLUvec4 *v1, const GLUvec4 *v2)
{
result->values[0] = v1->values[0] / v2->values[0];
result->values[1] = v1->values[1] / v2->values[1];
result->values[2] = v1->values[2] / v2->values[2];
result->values[3] = v1->values[3] / v2->values[3];
}
extern inline void gluAdd4v_4v(GLUvec4 *result,
const GLUvec4 *v1, const GLUvec4 *v2)
{
result->values[0] = v1->values[0] + v2->values[0];
result->values[1] = v1->values[1] + v2->values[1];
result->values[2] = v1->values[2] + v2->values[2];
result->values[3] = v1->values[3] + v2->values[3];
}
extern inline void gluSub4v_4v(GLUvec4 *result,
const GLUvec4 *v1, const GLUvec4 *v2)
{
result->values[0] = v1->values[0] - v2->values[0];
result->values[1] = v1->values[1] - v2->values[1];
result->values[2] = v1->values[2] - v2->values[2];
result->values[3] = v1->values[3] - v2->values[3];
}
extern inline void gluMult4v_f(GLUvec4 *result,
const GLUvec4 *v1, GLfloat f)
{
result->values[0] = v1->values[0] * f;
result->values[1] = v1->values[1] * f;
result->values[2] = v1->values[2] * f;
result->values[3] = v1->values[3] * f;
}
extern inline void gluDiv4v_f(GLUvec4 *result,
const GLUvec4 *v1, GLfloat f)
{
result->values[0] = v1->values[0] / f;
result->values[1] = v1->values[1] / f;
result->values[2] = v1->values[2] / f;
result->values[3] = v1->values[3] / f;
}
extern inline void gluAdd4v_f(GLUvec4 *result,
const GLUvec4 *v1, GLfloat f)
{
result->values[0] = v1->values[0] + f;
result->values[1] = v1->values[1] + f;
result->values[2] = v1->values[2] + f;
result->values[3] = v1->values[3] + f;
}
extern inline void gluSub4v_f(GLUvec4 *result,
const GLUvec4 *v1, GLfloat f)
{
result->values[0] = v1->values[0] - f;
result->values[1] = v1->values[1] - f;
result->values[2] = v1->values[2] - f;
result->values[3] = v1->values[3] - f;
}
extern inline void gluMult4m_f(GLUmat4 *result,
const GLUmat4 *m, GLfloat f)
{
GLUmat4 temp;
gluMult4v_f(& temp.col[0], & m->col[0], f);
gluMult4v_f(& temp.col[1], & m->col[1], f);
gluMult4v_f(& temp.col[2], & m->col[2], f);
gluMult4v_f(& temp.col[3], & m->col[3], f);
*result = temp;
}
extern inline void gluMult4m_4v(GLUvec4 *result,
const GLUmat4 *m, const GLUvec4 *v)
{
GLUvec4 temp[6];
unsigned i;
for (i = 0; i < 4; i++) {
gluMult4v_f(& temp[i], & m->col[i], v->values[i]);
}
gluAdd4v_4v(& temp[4], & temp[0], & temp[1]);
gluAdd4v_4v(& temp[5], & temp[2], & temp[3]);
gluAdd4v_4v(result, & temp[4], & temp[5]);
}
extern inline void gluAdd4m_4m(GLUmat4 *result,
const GLUmat4 *m1, const GLUmat4 *m2)
{
GLUmat4 temp;
gluAdd4v_4v(& temp.col[0], & m1->col[0], & m2->col[0]);
gluAdd4v_4v(& temp.col[1], & m1->col[1], & m2->col[1]);
gluAdd4v_4v(& temp.col[2], & m1->col[2], & m2->col[2]);
gluAdd4v_4v(& temp.col[3], & m1->col[3], & m2->col[3]);
*result = temp;
}
extern inline void gluSub4m_4m(GLUmat4 *result,
const GLUmat4 *m1, const GLUmat4 *m2)
{
GLUmat4 temp;
gluSub4v_4v(& temp.col[0], & m1->col[0], & m2->col[0]);
gluSub4v_4v(& temp.col[1], & m1->col[1], & m2->col[1]);
gluSub4v_4v(& temp.col[2], & m1->col[2], & m2->col[2]);
gluSub4v_4v(& temp.col[3], & m1->col[3], & m2->col[3]);
*result = temp;
}
extern inline GLfloat gluDot4_4v(const GLUvec4 *v1, const GLUvec4 *v2)
{
return v1->values[0] * v2->values[0]
+ v1->values[1] * v2->values[1]
+ v1->values[2] * v2->values[2]
+ v1->values[3] * v2->values[3];
}
extern inline GLfloat gluDot3_4v(const GLUvec4 *v1, const GLUvec4 *v2)
{
return v1->values[0] * v2->values[0]
+ v1->values[1] * v2->values[1]
+ v1->values[2] * v2->values[2];
}
extern inline GLfloat gluDot2_4v(const GLUvec4 *v1, const GLUvec4 *v2)
{
return v1->values[0] * v2->values[0]
+ v1->values[1] * v2->values[1];
}
extern inline void gluCross4v(GLUvec4 *result,
const GLUvec4 *v1, const GLUvec4 *v2)
{
GLUvec4 temp;
temp.values[0] = (v1->values[1] * v2->values[2])
- (v1->values[2] * v2->values[1]);
temp.values[1] = (v1->values[2] * v2->values[0])
- (v1->values[0] * v2->values[2]);
temp.values[2] = (v1->values[0] * v2->values[1])
- (v1->values[1] * v2->values[0]);
temp.values[3] = 0.0;
*result = temp;
}
extern inline void gluOuter4v(GLUmat4 *result,
const GLUvec4 *v1, const GLUvec4 *v2)
{
GLUmat4 temp;
gluMult4v_f(& temp.col[0], v1, v2->values[0]);
gluMult4v_f(& temp.col[1], v1, v2->values[1]);
gluMult4v_f(& temp.col[2], v1, v2->values[2]);
gluMult4v_f(& temp.col[3], v1, v2->values[3]);
*result = temp;
}
extern inline GLfloat gluLengthSqr4v(const GLUvec4 *v)
{
return gluDot4_4v(v, v);
}
extern inline GLfloat gluLength4v(const GLUvec4 *v)
{
return sqrt(gluLengthSqr4v(v));
}
extern inline void gluNormalize4v(GLUvec4 *result, const GLUvec4 *v)
{
gluDiv4v_f(result, v, gluLength4v(v));
}
extern inline void gluTranspose4m(GLUmat4 *result, const GLUmat4 *m)
{
unsigned i;
unsigned j;
GLUmat4 temp;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
temp.col[i].values[j] = m->col[j].values[i];
}
}
*result = temp;
}
extern inline void gluMult4m_4m(GLUmat4 *result,
const GLUmat4 *m1, const GLUmat4 *m2)
{
GLUmat4 temp;
unsigned i;
for (i = 0; i < 4; i++) {
gluMult4m_4v(& temp.col[i], m1, & m2->col[i]);
}
*result = temp;
}
extern inline void gluTranslate3f(GLUmat4 *result,
GLfloat x, GLfloat y, GLfloat z)
{
memcpy(result, & gluIdentityMatrix, sizeof(gluIdentityMatrix));
result->col[3].values[0] = x;
result->col[3].values[1] = y;
result->col[3].values[2] = z;
}
#ifdef __cplusplus
extern inline GLfloat gluDot4(const GLUvec4 &v1, const GLUvec4 &v2)
{
return v1.values[0] * v2.values[0]
+ v1.values[1] * v2.values[1]
+ v1.values[2] * v2.values[2]
+ v1.values[3] * v2.values[3];
}
extern inline GLfloat gluDot3(const GLUvec4 &v1, const GLUvec4 &v2)
{
return v1.values[0] * v2.values[0]
+ v1.values[1] * v2.values[1]
+ v1.values[2] * v2.values[2];
}
extern inline GLfloat gluDot2(const GLUvec4 &v1, const GLUvec4 &v2)
{
return v1.values[0] * v2.values[0]
+ v1.values[1] * v2.values[1];
}
inline GLUvec4 GLUvec4::operator+(const GLUvec4 &v) const
{
return GLUvec4(values[0] + v.values[0],
values[1] + v.values[1],
values[2] + v.values[2],
values[3] + v.values[3]);
}
inline GLUvec4 GLUvec4::operator-(const GLUvec4 &v) const
{
return GLUvec4(values[0] - v.values[0],
values[1] - v.values[1],
values[2] - v.values[2],
values[3] - v.values[3]);
}
inline GLUvec4 GLUvec4::operator*(const GLUvec4 &v) const
{
return GLUvec4(values[0] * v.values[0],
values[1] * v.values[1],
values[2] * v.values[2],
values[3] * v.values[3]);
}
inline GLUvec4 GLUvec4::operator*(GLfloat f) const
{
return GLUvec4(values[0] * f,
values[1] * f,
values[2] * f,
values[3] * f);
}
inline GLUvec4 GLUvec4::operator*(const GLUmat4 &m) const
{
return GLUvec4(gluDot4(*this, m.col[0]),
gluDot4(*this, m.col[1]),
gluDot4(*this, m.col[2]),
gluDot4(*this, m.col[3]));
}
inline GLUmat4 GLUmat4::operator+(const GLUmat4 &m) const
{
GLUmat4 temp;
gluAdd4m_4m(& temp, this, &m);
return temp;
}
inline GLUmat4 GLUmat4::operator-(const GLUmat4 &m) const
{
return GLUmat4(col[0] - m.col[0],
col[1] - m.col[1],
col[2] - m.col[2],
col[3] - m.col[3]);
}
inline GLUmat4 GLUmat4::operator*(GLfloat f) const
{
GLUmat4 temp;
gluMult4m_f(& temp, this, f);
return temp;
}
inline GLUvec4 GLUmat4::operator*(const GLUvec4 &v) const
{
return (col[0] * v.values[0])
+ (col[1] * v.values[1])
+ (col[2] * v.values[2])
+ (col[3] * v.values[3]);
}
inline GLUmat4 GLUmat4::operator*(const GLUmat4 &m) const
{
GLUmat4 temp;
gluMult4m_4m(& temp, this, &m);
return temp;
}
#endif /* __cplusplus */