able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/opengl/server/inc/procs.h

594 lines
23 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#ifndef __glprocs_h_
#define __glprocs_h_
/*
** Copyright 1991-1993, Silicon Graphics, Inc.
** All Rights Reserved.
**
** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
** the contents of this file may not be disclosed to third parties, copied or
** duplicated in any form, in whole or in part, without the prior written
** permission of Silicon Graphics, Inc.
**
** RESTRICTED RIGHTS LEGEND:
** Use, duplication or disclosure by the Government is subject to restrictions
** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
** and Computer Software clause at DFARS 252.227-7013, and/or in similar or
** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
** rights reserved under the Copyright Laws of the United States.
*/
#include "types.h"
/*
** These typedefs are used to normalize the calling conventions
** for the span procs. Some of the arguments are not used by
** many of the span procs, but the arguments are present so that
** the function pointers in the spanProcsRec can be interchanged.
** The idea is to move up in the calling sequence as high as possible
** the final "store" span proc.
**
** The type __GLspanFunc returns GL_TRUE if it stippled the span while
** processing it. If it also stippled the span all black, it sets
** gc->polygon.shader.done to GL_TRUE.
**
** The type __GLstippledSpanFunc return GL_TRUE if it stippled the span
** to all black, and GL_FALSE otherwise.
*/
typedef GLboolean (FASTCALL *__GLspanFunc)(__GLcontext *gc);
typedef GLboolean (FASTCALL *__GLstippledSpanFunc)(__GLcontext *gc);
#define __GL_MAX_SPAN_FUNCS 15
#define __GL_MAX_LINE_FUNCS 16
typedef struct __GLspanProcsRec {
/*
** First phase of span processing. Clip the span so that it won't
** render outside of the intersection of the window box and the
** scissor box. Then call the stipple proc to replicate the stipple
** (and rotate it) sufficient for rendering w pixels. If there is no
** active polygon stipple then the stipple proc is skipped, and the
** unstippled form of the next phase of procs is used until stippling
** becomes necessary.
**
** Second phase of span processing. Apply the various test functions
** producing at the end a final stipple for the span.
** Each test procedure outputs a new stipple as
** needed, calling the stippled form of the next proc only if the
** test failed somewhere in the span.
**
** Next phase of span processing. This phase is responsible for
** generating the final colors to be stored. The operations are
** applied in order as shown below, producing at the end the final
** color values. draw is used to replicate the span so that it
** properly renders to the correct number of destination buffers
** (e.g., when drawBuffer is FRONT_AND_BACK).
**
** Final phase of span rendering. Apply blend function, dither
** operation, logic-op and writemask before calling the store
** proc. When blending, logic-oping, or writemasking is being done,
** the fetch proc will be used to read in the span (from the draw
** buffer) before proceeding furthur.
*/
/*
** The 15 layers of the span procs are:
**
** scissor, poly stipple, alpha test, stencil test, depth test, shading,
** texturing, fogging, FRONT_AND_BACK drawing, fetching, blending,
** dithering, logic op, masking, storing.
*/
__GLspanFunc spanFuncs[__GL_MAX_SPAN_FUNCS];
__GLstippledSpanFunc stippledSpanFuncs[__GL_MAX_SPAN_FUNCS];
/*
** The number of procs stored in the span function arrays. n is
** the number applied prior to span replication (for drawing to both
** FRONT_AND_BACK buffers), and m is the total number applied.
*/
GLint n, m;
/*
** This is the root span function. It is called when a span needs
** processing.
*/
__GLspanFunc processSpan;
/*
** Assembly routine to depth test a single pixel. There is no prototype,
** since variables are passed in registers.
*/
void (*depthTestPixel)(void);
} __GLspanProcs;
typedef struct __GLlineProcsRec {
/*
** The line procs are very similar to the span procs. The biggest
** difference is that they iterate along a line instead of a span.
**
** The prototypes for the line procs are identical to the prototypes
** to the poly span paths so that some of the leaves can be shared.
**
** The layers of the line procs are as follows:
**
** scissor, line stipple, alpha test, stencil test, depth test, shading,
** texturing, fogging, wide line duplication, FRONT_AND_BACK drawing,
** fetching, blending, dithering, logic op, masking, storing.
*/
__GLspanFunc lineFuncs[__GL_MAX_LINE_FUNCS];
__GLstippledSpanFunc stippledLineFuncs[__GL_MAX_LINE_FUNCS];
/*
** The number of procs stored in the line function arrays. n is
** the number applied prior to wide line replication (for lines of
** width greater than 1), m is the total number applied prior to
** FRONT_AND_BACK line replication, and l is the total number applied
** altogether (l > m > n).
*/
GLint n, m, l;
/*
** This is the root line function. It is called when a line needs
** processing.
*/
__GLspanFunc processLine;
/*
** One of these procs is called after the first n procs have been
** completed. This proc is responsible for replicating a wide line
** numerous times.
*/
__GLspanFunc wideLineRep;
__GLstippledSpanFunc wideStippledLineRep;
/*
** One of these procs is called after the first m procs have been
** completed. This proc is responsible for replication a line to
** be drawn to both the FRONT and BACK buffers.
*/
__GLspanFunc drawLine;
__GLstippledSpanFunc drawStippledLine;
/*
** Assembly routine to depth test a single pixel. There is no prototype,
** since variables are passed in registers.
**
** depthTestPixel is for unstippled lines,
** depthTestSPixel is for stippled lines,
** depthTestPixelSF is for unstippled lines with stenciling enabled
** depthTestSPixelSF is for stippled lines with stenciling enabled.
*/
void (*depthTestPixel)(void);
void (*depthTestSPixel)(void);
void (*depthTestPixelSF)(void);
void (*depthTestSPixelSF)(void);
} __GLlineProcs;
typedef struct __GLpixelSpanProcsRec {
/*
** Pixel span reading routines. For examples of each, see pixel/px_read.c.
**
** These routines read pixel spans for CI, RGBA, Stencil and Depth. The
** base versions perform pixel skipping, and the '2' versions simply read
** the span straight. The RGBA routines should produce outgoing scaled
** colors.
*/
void (FASTCALL *spanReadCI)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
void (FASTCALL *spanReadCI2)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
void (FASTCALL *spanReadRGBA)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
void (FASTCALL *spanReadRGBA2)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
void (FASTCALL *spanReadDepth)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
void (FASTCALL *spanReadDepth2)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
void (FASTCALL *spanReadStencil)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
void (FASTCALL *spanReadStencil2)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
/*
** Pixel span rendering routines. For examples of each, see
** pixel/px_render.c.
**
** These routines render pixel spans for CI, RGBA, Stencil and Depth. The
** base versions perform pixel replication, and the '2' versions simply
** render the span straight. The RGBA routines should take incoming
** scaled colors.
*/
void (FASTCALL *spanRenderCI)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
void (FASTCALL *spanRenderCI2)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
void (FASTCALL *spanRenderRGBA)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
void (FASTCALL *spanRenderRGBA2)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
void (FASTCALL *spanRenderDepth)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
void (FASTCALL *spanRenderDepth2)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
void (FASTCALL *spanRenderStencil)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
void (FASTCALL *spanRenderStencil2)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLvoid *span);
} __GLpixelSpanProcs;
/************************************************************************/
/*
** Procedures required for phong shading.
*/
#ifdef GL_WIN_phong_shading
typedef struct __GLphongProcsRec {
void (*InitSpanInterpolation) (__GLcontext *gc);
void (*UpdateAlongSpan) (__GLcontext *gc);
void (*ComputeRGBColor) (__GLcontext *gc, __GLcolor *outColor);
void (*ComputeCIColor) (__GLcontext *gc, __GLcolor *outColor);
void (*InitLineParams) (__GLcontext *gc, __GLvertex *v0, __GLvertex *v1,
__GLfloat invDelta);
#ifdef __JUNKED_CODE
void (*InitInterpolation) (__GLcontext *gc, __GLvertex *v);
void (*SetInitParams) (__GLcontext *gc, __GLvertex *a,
__GLcoord *an, __GLfloat dx,
__GLfloat dy);
void (*UpdateAlongEdge) (__GLcontext *gc, __GLfloat dxLeft,
GLboolean useBigStep);
#endif //__JUNKED_CODE
} __GLphongProcs;
#endif //GL_WIN_phong_shading
/************************************************************************/
#ifdef unix
typedef struct _XDisplay __GLdisplay;
typedef unsigned long __GLdrawable;
typedef unsigned long __GLfont;
#endif
#ifdef NT
typedef void (FASTCALL *PFN_RENDER_LINE)(__GLcontext *gc, __GLvertex *v0,
__GLvertex *v1, GLuint flags);
typedef void (FASTCALL *PFN_VERTEX_CLIP_PROC)(__GLvertex*, const __GLvertex*,
const __GLvertex*, __GLfloat);
typedef void (FASTCALL *PFN_RENDER_TRIANGLE)(__GLcontext *gc, __GLvertex *v0,
__GLvertex *v1, __GLvertex *v2);
typedef void (FASTCALL *PFN_FILL_TRIANGLE)(__GLcontext *gc, __GLvertex *v0,
__GLvertex *v1,
__GLvertex *v2, GLboolean ccw);
#endif
typedef struct __GLprocsRec __GLprocs;
struct __GLprocsRec {
/**************************************************************/
/*
** Context function pointer management procs.
*/
/* Validate the context derived state */
void (FASTCALL *validate)(__GLcontext *gc);
/*
** Pick procs to choose the other procs in this structure. These
** default to procedures in pick.c (and elsewhere) but can be
** overriden by the machine dependent context code.
*/
void (FASTCALL *pickBlendProcs)(__GLcontext *gc);
void (FASTCALL *pickColorMaterialProcs)(__GLcontext *gc);
void (FASTCALL *pickTextureProcs)(__GLcontext *gc);
void (FASTCALL *pickFogProcs)(__GLcontext *gc);
void (FASTCALL *pickPointProcs)(__GLcontext *gc);
void (FASTCALL *pickLineProcs)(__GLcontext *gc);
void (FASTCALL *pickTriangleProcs)(__GLcontext *gc);
void (FASTCALL *pickRenderBitmapProcs)(__GLcontext *gc);
void (FASTCALL *pickPixelProcs)(__GLcontext *gc);
void (FASTCALL *pickClipProcs)(__GLcontext *gc);
void (FASTCALL *pickParameterClipProcs)(__GLcontext *gc);
void (FASTCALL *pickBufferProcs)(__GLcontext *gc);
void (FASTCALL *pickStoreProcs)(__GLcontext *gc);
void (FASTCALL *pickSpanProcs)(__GLcontext *gc);
void (FASTCALL *pickVertexProcs)(__GLcontext *gc);
int (FASTCALL *pickDepthProcs)(__GLcontext *gc);
void (FASTCALL *pickAllProcs)(__GLcontext *gc);
/**************************************************************/
/*
** Function pointers used for transformation, viewport and normal
** processing.
*/
/* Called when the viewport changes */
void (FASTCALL *applyViewport)(__GLcontext *gc);
/**************************************************************/
#ifdef NT
GLuint (FASTCALL *paClipCheck)(__GLcontext *gc, POLYARRAY *pa,
POLYDATA *pdLast);
#endif
#ifdef NT
void (FASTCALL *paCalcTexture)(__GLcontext *gc, POLYARRAY *pa);
#endif
/**************************************************************/
/*
** Function pointers used for coloring
*/
/*
** applyColor processes a color from the user that has been loaded
** into the gc->state.current.color. If color material is enabled
** then the color will be applied the appropriate material(s).
** Otherwise, the color will be either scaled or scaled and clamped.
*/
void (FASTCALL *applyColor)(__GLcontext *gc);
#ifdef NT
PFN_POLYARRAYCALCCOLORSKIP paCalcColorSkip;
PFN_POLYARRAYCALCCOLOR paCalcColor;
PFN_POLYARRAYAPPLYCHEAPFOG paApplyCheapFog;
#endif
/*
** Apply a color change to a material.
*/
void (FASTCALL *changeMaterial)(__GLcontext *gc, __GLmaterialState *ms,
__GLmaterialMachine *msm);
/**************************************************************/
/*
** Z buffer test procs
*/
/*
** assembly routines to depth test a single pixel. These are
** highly optimized C-callable routines...
*/
GLboolean (FASTCALL *DTPixel)( __GLzValue z, __GLzValue *zfb );
/**************************************************************/
/*
** Function pointers used for polygon, triangle, quad and rect
** rendering.
*/
/* Rendering */
PFN_RENDER_TRIANGLE renderTriangle;
PFN_FILL_TRIANGLE fillTriangle;
PFN_FILL_TRIANGLE fillTriangle2;
/* Clipping */
void (FASTCALL *clipTriangle)(__GLcontext *gc, __GLvertex *v0,
__GLvertex *v1,
__GLvertex *v2, GLuint orCodes);
void (FASTCALL *clipPolygon)(__GLcontext *gc, __GLvertex *v0, GLint nv);
PFN_VERTEX_CLIP_PROC polyClipParam;
/* Function pointers specific to span level rendering */
__GLspanProcs span;
/* Function pointers specific to line level rendering */
__GLlineProcs line;
/* Function pointers specific to pixel routines (DrawPixels, CopyPixels,
** ReadPixels).
*/
__GLpixelSpanProcs pixel;
/**************************************************************/
/*
** Function pointers used for lines.
*/
#ifdef NT
void (FASTCALL *lineBegin)(__GLcontext *gc);
void (FASTCALL *lineEnd)(__GLcontext *gc);
PFN_RENDER_LINE renderLine;
PFN_RENDER_LINE renderLine2;
#else
void (FASTCALL *renderLine)(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1);
void (FASTCALL *renderLine2)(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1);
#endif
/* Line specific parameter clip proc */
PFN_VERTEX_CLIP_PROC lineClipParam;
/*
** The default slow path renderLine proc simply initializes some line
** data, and then calls this proc.
*/
void (FASTCALL *rasterizeLine)(__GLcontext *gc);
/**************************************************************/
/*
** Point procs.
*/
void (FASTCALL *renderPoint)(__GLcontext *gc, __GLvertex *v);
#ifdef __BUGGY_RENDER_POINT
void (FASTCALL *renderPoint2)(__GLcontext *gc, __GLvertex *v);
#endif //__BUGGY_RENDER_POINT
/**************************************************************/
/*
** Bitmap procs.
*/
void (*bitmap)(__GLcontext *gc, GLint width, GLint height,
GLfloat xOrig, GLfloat yOrig,
GLfloat xMove, GLfloat yMove, const GLubyte bits[]);
void (FASTCALL *renderBitmap)(__GLcontext *gc, const __GLbitmap *bitmap,
const GLubyte *bits);
/**************************************************************/
/*
** Texturing procs. The rho procs compute the next rho value
** for mipmap selection. They might be simple procedures if
** mipmapping is not being done.
*/
__GLfloat (*calcLineRho)(__GLcontext *gc, __GLfloat s,
__GLfloat t, __GLfloat winv);
__GLfloat (*calcPolygonRho)(__GLcontext *gc, const __GLshade *sh,
__GLfloat s, __GLfloat t, __GLfloat winv);
void (*texture)(__GLcontext *gc, __GLcolor *color, __GLfloat s,
__GLfloat t, __GLfloat rho);
/**************************************************************/
/*
** Fogging procs. Vertex fogging computes the fog factor at the
** vertex and then interpolates that. High quality fogging
** (GL_FOG_HINT set to GL_NICEST) interpolates the eyeZ at then
** evaluates the fog function for each fragment.
*/
void (*fogPoint)(__GLcontext *gc, __GLfragment *frag, __GLfloat eyeZ);
void (*fogColor)(__GLcontext *gc, __GLcolor *out, __GLcolor *in,
__GLfloat eyeZ);
__GLfloat (FASTCALL *fogVertex)(__GLcontext *gc, __GLvertex *vx);
/**************************************************************/
/*
** Blend an incoming fragment according to the current blending
** mode and return a pointer to the new fragment which contains
** the updated colors.
*/
void (*blend)(__GLcontext *gc, __GLcolorBuffer *cfb,
const __GLfragment *frag, __GLcolor *result);
void (*blendColor)(__GLcontext *gc, const __GLcolor *source,
const __GLcolor *dest, __GLcolor *result);
void (*blendSrc)(__GLcontext *gc, const __GLcolor *source,
const __GLcolor *dest, __GLcolor *result);
void (*blendDst)(__GLcontext *gc, const __GLcolor *frag,
const __GLcolor *dest, __GLcolor *result);
void (FASTCALL *blendSpan)(__GLcontext *gc);
/**************************************************************/
/* Pixel proc pointers */
void (*drawPixels)(__GLcontext *gc, GLint width, GLint height,
GLenum format, GLenum type, const GLvoid *pixels,
GLboolean packed);
void (*copyPixels)(__GLcontext *gc, GLint x, GLint y,
GLsizei width, GLsizei height, GLenum type);
void (*readPixels)(__GLcontext *gc, GLint x, GLint y,
GLsizei width, GLsizei height,
GLenum format, GLenum type, const GLvoid *pixels);
void (FASTCALL *copyImage)(__GLcontext *gc, __GLpixelSpanInfo *spanInfo,
GLboolean applyPixelTransfer);
void (FASTCALL *pxStore)(__GLcolorBuffer *cfb, const __GLfragment *frag);
/**************************************************************/
/*
** Store a fragment into the given frame buffer, applying any
** currently active rasterization modes properly.
*/
void (FASTCALL *store)(__GLcolorBuffer *cfb, const __GLfragment *frag);
/*
** Store a fragment into the given frame buffer.
*/
void (FASTCALL *cfbStore)(__GLcolorBuffer *cfb, const __GLfragment *frag);
/**************************************************************/
/*
** Function pointers used for attribute processing.
*/
/* called when the polygon stipple changes */
void (FASTCALL *convertPolygonStipple)(__GLcontext *gc);
#ifdef GL_WIN_phong_shading
/**************************************************************/
/*
** Function pointers used for Phong shading.
*/
__GLphongProcs phong;
/**************************************************************/
#endif //GL_WIN_phong_shading
};
extern void FASTCALL __glGenericValidate(__GLcontext *gc);
/* Generic (portable) implementations of the pick procs */
extern void FASTCALL __glGenericPickBlendProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickColorMaterialProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickTextureProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickFogProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickParameterClipProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickPointProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickTriangleProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickLineProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickRenderBitmapProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickClipProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickBufferProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickStoreProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickSpanProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickVertexProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickPixelProcs(__GLcontext *gc);
extern int FASTCALL __glGenericPickDepthProcs(__GLcontext *gc);
extern void FASTCALL __glGenericPickAllProcs(__GLcontext *gc);
/* some useful store procs */
extern void FASTCALL __glDoStore_ASD(__GLcolorBuffer *, const __GLfragment *);
extern void FASTCALL __glDoStore_AS(__GLcolorBuffer *, const __GLfragment *);
extern void FASTCALL __glDoStore_AD(__GLcolorBuffer *, const __GLfragment *);
extern void FASTCALL __glDoStore_SD(__GLcolorBuffer *, const __GLfragment *);
extern void FASTCALL __glDoStore_A(__GLcolorBuffer *, const __GLfragment *);
extern void FASTCALL __glDoStore_S(__GLcolorBuffer *, const __GLfragment *);
extern void FASTCALL __glDoStore_D(__GLcolorBuffer *, const __GLfragment *);
extern void FASTCALL __glDoStore(__GLcolorBuffer *, const __GLfragment *);
extern void FASTCALL __glDoNullStore(__GLcolorBuffer *, const __GLfragment *);
extern void FASTCALL __glDoDoubleStore(__GLcolorBuffer *, const __GLfragment *);
/* Some predicates for pick procs to use */
extern GLboolean FASTCALL __glFastRGBA(__GLcontext *gc);
extern GLboolean FASTCALL __glNeedAlpha(__GLcontext *gc);
/* Save routines */
void FASTCALL FASTCALL __glSaveN(__GLcontext *gc, __GLvertex *vx);
void FASTCALL FASTCALL __glSaveC(__GLcontext *gc, __GLvertex *vx);
void FASTCALL FASTCALL __glSaveCI(__GLcontext *gc, __GLvertex *vx);
void FASTCALL FASTCALL __glSaveT(__GLcontext *gc, __GLvertex *vx);
void FASTCALL FASTCALL __glSaveCT(__GLcontext *gc, __GLvertex *vx);
void FASTCALL FASTCALL __glSaveNT(__GLcontext *gc, __GLvertex *vx);
void FASTCALL FASTCALL __glSaveCAll(__GLcontext *gc, __GLvertex *vx);
void FASTCALL FASTCALL __glSaveCIAll(__GLcontext *gc, __GLvertex *vx);
#ifdef NT
void FASTCALL PolyArrayCalcTexture(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayCalcObjectLinearSameST(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayCalcObjectLinear(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayCalcEyeLinearSameST(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayCalcEyeLinear(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayCalcSphereMap(__GLcontext *gc, POLYARRAY *pa);
void FASTCALL PolyArrayCalcMixedTexture(__GLcontext *gc, POLYARRAY *pa);
#endif
#ifdef _X86_
void initClipCodesTable(); // Defined in so_prim.c
void initInvSqrtTable(); // Defined in so_prim.c
#endif // _X86_
#endif /* __glprocs_h_ */
Reference in a new issue Copy permalink