diff --git a/3rdparty/tinygl-0.4-ugfx/BeOS/GLView.cpp b/3rdparty/tinygl-0.4-ugfx/BeOS/GLView.cpp new file mode 100644 index 00000000..778107e6 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/BeOS/GLView.cpp @@ -0,0 +1,205 @@ +#include "GLView.h" +#include +#include + +BLocker BGLView::locker; + +BGLView::BGLView(BRect rect, char *name, + ulong resizingMode, ulong mode, + ulong options) + : BView(rect, name, resizingMode, mode|B_FRAME_EVENTS|B_WILL_DRAW) +{ +#ifdef __INTEL__ + color_space cs = B_RGB16_LITTLE; +#else + color_space cs = B_RGB16_BIG; +#endif + this->bitmaps[0] = new BBitmap(rect, cs, false, true); + this->bitmaps[1] = new BBitmap(rect, cs, false, true); + + this->currBitmap = 0; + int w = this->bitmaps[0]->BytesPerRow() / 2; + int h = rect.Height() + 1; + void *buffers[2]; + buffers[0] = this->bitmaps[0]->Bits(); + buffers[1] = this->bitmaps[1]->Bits(); + this->context = ostgl_create_context(w, h, 16, buffers, 2); + ostgl_make_current(this->context, 0); +} + +BGLView::~BGLView() +{ + ostgl_delete_context(this->context); + delete this->bitmaps[0]; + delete this->bitmaps[1]; +} + +void +BGLView::LockGL() +{ + BGLView::locker.Lock(); + ostgl_make_current(this->context, this->currBitmap); +} + +void +BGLView::UnlockGL() +{ + BGLView::locker.Unlock(); +} + +void +BGLView::SwapBuffers() +{ + if (Window()->Lock()) { + DrawBitmap(this->bitmaps[this->currBitmap]); + Window()->Unlock(); + this->currBitmap ^= 1; + } +} + +/* +BView * +BGLView::EmbeddedView() +{ + return NULL; +} + +status_t +BGLView::CopyPixelsOut(BPoint source, BBitmap *dest) +{ + assert(0); + return 0; +} + +status_t +BGLView::CopyPixelsIn(BBitmap *source, BPoint dest) +{ + assert(0); + return 0; +} +*/ + +void +BGLView::ErrorCallback(GLenum /*errorCode*/) +{ +} + +void +BGLView::Draw(BRect rect) +{ + //fprintf(stderr, "GLView::Draw()"); + DrawBitmap(this->bitmaps[this->currBitmap^1], rect, rect); +} + +void +BGLView::AttachedToWindow() +{ +} + +void +BGLView::AllAttached() +{ +} + +void +BGLView::DetachedFromWindow() +{ +} + +void +BGLView::AllDetached() +{ +} + +void +BGLView::FrameResized(float w, float h) +{ + delete this->bitmaps[0]; + delete this->bitmaps[1]; +#ifdef __INTEL__ + color_space cs = B_RGB16_LITTLE; +#else + color_space cs = B_RGB16_BIG; +#endif + this->bitmaps[0] = new BBitmap(BRect(0,0, w-1, h-1), + cs, false, true); + this->bitmaps[1] = new BBitmap(BRect(0,0, w-1, h-1), + cs, false, true); + int w2 = this->bitmaps[0]->BytesPerRow() / 2; + void *buffers[2]; + buffers[0] = this->bitmaps[0]->Bits(); + buffers[1] = this->bitmaps[1]->Bits(); + ostgl_resize(this->context, w2, h, buffers); +} + +/* +status_t +BGLView::Perform(perform_code d, void *arg) +{ + +} +*/ + +// +// the rest are pass-through functions +// + +status_t +BGLView::Archive(BMessage *data, bool deep) const +{ + return BView::Archive(data, deep); +} + +void +BGLView::MessageReceived(BMessage *msg) +{ + BView::MessageReceived(msg); +} + +void +BGLView::SetResizingMode(uint32 mode) +{ + BView::SetResizingMode(mode); +} + +void +BGLView::Show() +{ + BView::Show(); +} + +void +BGLView::Hide() +{ + BView::Hide(); +} + +BHandler * +BGLView::ResolveSpecifier(BMessage *msg, int32 index, + BMessage *specifier, int32 form, + const char *property) +{ + return BView::ResolveSpecifier(msg, index, specifier, form, property); +} + +status_t +BGLView::GetSupportedSuites(BMessage *data) +{ + return BView::GetSupportedSuites(data); +} + +/* +void +BGLView::DirectConnected( direct_buffer_info *info ) +{ + BView::DirectConnected(info); +} +*/ + +/* +void +BGLView::EnableDirectMode( bool enabled ) +{ + BView::EnableDirectMode(enabled); +} +*/ diff --git a/3rdparty/tinygl-0.4-ugfx/BeOS/GLView.h b/3rdparty/tinygl-0.4-ugfx/BeOS/GLView.h new file mode 100644 index 00000000..6791e5aa --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/BeOS/GLView.h @@ -0,0 +1,72 @@ +#ifndef _glview_h_ +#define _glview_h_ + +#define BGL_RGB 0 +#define BGL_INDEX 1 +#define BGL_SINGLE 0 +#define BGL_DOUBLE 2 +#define BGL_DIRECT 0 +#define BGL_INDIRECT 4 +#define BGL_ACCUM 8 +#define BGL_ALPHA 16 +#define BGL_DEPTH 32 +#define BGL_OVERLAY 64 +#define BGL_UNDERLAY 128 +#define BGL_STENCIL 512 + +#include +#include +#include +#include +#include +#include + +class BGLView : public BView { +public: + BGLView(BRect rect, char *name, + ulong resizingMode, ulong mode, + ulong options); + virtual ~BGLView(); + + void LockGL(); + void UnlockGL(); + void SwapBuffers(); +// BView *EmbeddedView(); +// status_t CopyPixelsOut(BPoint source, BBitmap *dest); +// status_t CopyPixelsIn(BBitmap *source, BPoint dest); + + virtual void ErrorCallback(GLenum errorCode); + virtual void Draw(BRect updateRect); + virtual void AttachedToWindow(); + virtual void AllAttached(); + virtual void DetachedFromWindow(); + virtual void AllDetached(); + virtual void FrameResized(float width, float height); +// virtual status_t Perform(perform_code d, void *arg); + + // + // Methods below are pass-throughs to BView for the moment. + // + + virtual status_t Archive(BMessage *data, bool deep = true) const; + virtual void MessageReceived(BMessage *msg); + virtual void SetResizingMode(uint32 mode); + + virtual void Show(); + virtual void Hide(); + + virtual BHandler *ResolveSpecifier(BMessage *msg, int32 index, + BMessage *specifier, int32 form, + const char *property); + virtual status_t GetSupportedSuites(BMessage *data); + //void DirectConnected( direct_buffer_info *info ); + //void EnableDirectMode( bool enabled ); + +private: + ostgl_context *context; + BBitmap *bitmaps[2]; + int currBitmap; + static BLocker locker; +}; + +#endif // _glview_h_ diff --git a/3rdparty/tinygl-0.4-ugfx/BeOS/Makefile b/3rdparty/tinygl-0.4-ugfx/BeOS/Makefile new file mode 100644 index 00000000..0113b3f6 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/BeOS/Makefile @@ -0,0 +1,16 @@ +OBJS=GLView.o +INCLUDES = -I../include +LIB = libGLView.a + +all: $(LIB) + +$(LIB): $(OBJS) + rm -f $(LIB) + ar rcs $(LIB) $(OBJS) + cp $(LIB) ../lib + +clean: + rm -f *~ *.o *.a + +GLView.o: GLView.cpp GLView.h + $(CC) $(CFLAGS) $(INCLUDES) -c GLView.cpp diff --git a/3rdparty/tinygl-0.4-ugfx/Changelog b/3rdparty/tinygl-0.4-ugfx/Changelog new file mode 100644 index 00000000..76f717ea --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/Changelog @@ -0,0 +1,38 @@ +version 0.4: + - added 24/32 bit rendering support (Olivier Landemarre - F. Bellard) + - fixed GL_TRIANGLE_STRIP (Olivier Landemarre) + - added gl_malloc, gl_free, gl_zalloc wrappers (Olivier Landemarre) + +version 0.3: + - added NanoX API (nglx) (F. Bellard) + - added gears example and unified GUI in examples (F. Bellard) + - added TGL_FEATURE_RENDER_BITS so that it will be possible to render + natively in 15/16/24 or 32 bits. (F. Bellard) + - interpolated lines (Olivier Landemarre) + - fast no shading case (Olivier Landemarre) + - fast no projection case (Olivier Landemarre) + +version 0.2: Fabrice Bellard + - added 24/32 bpp support. Added some features.h ifdefs. + - fixed some error reporting cases in the examples + - endianness is deduced from the glibc (BYTE_ORDER macro) + +version 0.19: Peder Blekken + - new files BeOS/* src/msghandling.*, src/arrays.*, src/oscontext.c + include/GL/oscontext.h src/features.h + - added support for BeOS, see README.BEOS + - added support for drawing convex polygons with unlimited # of vertices + - added support for GL_LIGHT_MODEL_TWO_SIDE + - added generic rotation code for glopRotate + - added support for opengl 1.1 arrays + - added support for glPolygonOffset, not implemented. + - added glGetFloatv, limited support. + - added some pnames for glGetIntegerv + - added some empty functions in include/GL/gl.h to compile VRMLView + - added GL_VERSION_1_1 define in include/GL/gl.h + - fixed "bug" when context->gl_resize_viewport is not set. + - fixed bug in glBindTexture (didn't accept texture object 0) + +version 0.1: + - Initial revision, Fabrice Bellard + diff --git a/3rdparty/tinygl-0.4-ugfx/INSTALL b/3rdparty/tinygl-0.4-ugfx/INSTALL new file mode 100644 index 00000000..2a9d7f13 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/INSTALL @@ -0,0 +1,10 @@ +Installation: + +- Edit config.mk and change what is needed. You can also look at +src/zfeatures.h to change very specific details (only useful to tune +TinyGL to your needs). You can link the examples with either OpenGL, +Mesa or TinyGL. + +- Type 'make'. The library 'libTinyGL.a' is copied into './lib'. The +examples are build in './examples'. Only the directories './lib' and +'./include' are needed to use TinyGL from another program. diff --git a/3rdparty/tinygl-0.4-ugfx/LICENCE b/3rdparty/tinygl-0.4-ugfx/LICENCE new file mode 100644 index 00000000..eefacaf9 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/LICENCE @@ -0,0 +1,22 @@ +Copyright notice: + + (C) 1997-1998 Fabrice Bellard + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product and its documentation + *is* required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + +If you redistribute modified sources, I would appreciate that you +include in the files history information documenting your changes. diff --git a/3rdparty/tinygl-0.4-ugfx/LIMITATIONS b/3rdparty/tinygl-0.4-ugfx/LIMITATIONS new file mode 100644 index 00000000..a20a8639 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/LIMITATIONS @@ -0,0 +1,206 @@ + +Here are listed the functions that TinyGL understands with the known +limitations. The non mentionned functions are *not* implemented and +must not be used. + + +************ glEnable / glDisable + +- The following flags are handled: + +GL_CULL_FACE, GL_LIGHTING, GL_COLOR_MATERIAL, GL_TEXTURE_2D, GL_NORMALIZE, +GL_LIGHTx, GL_POLYGON_OFFSET_FILL, GL_POLYGON_OFFSET_POINT, +GL_POLYGON_OFFSET_LINE + + +- GL_DEPTH_TEST is accepted, but it is only used for lines. For all + other primitives, Z buffer use is assumed. The DepthMode is + hardcoded as GL_LESS (OpenGL default). + +************ glShadeModel + +OK. + +************ glCullFace + +OK. + +************ glPolygonMode + +OK. + +************ glBegin + +No tests are performed to prevent some functions of being executed +between glBegin/glEnd. + +************ glEnd + +OK. + +************ glVertex + +Some prototypes are not implemented. + + +************ glColor + +Some prototypes are not implemented. + +************ glNormal + +Some prototypes are not implemented. + +************ glTexCoord + +- Some prototypes are not implemented. + +- The Matrix transformation is not applied yet. + +************ glEdgeFlag + +OK. The edge handling has to be tested, although it is not much useful +in TinyGL. + +************ glMatrixMode / glLoadMatrixf / glLoadIdentity / glMultMatrixf / + glPushMatrix / glPopMatrix / glRotatef / glTranslatef / glScalef / + glFrustum + +- The prototypes with doubles are not implemented. + +************ glViewport + +GlViewport calls a function pointers to tell glx (or another display +system) to resize the Z buffer and the ximage. Made optional in +version 0.2. + +************ glGenLists / glIsList / glNewList / glEndList / glCallList + +OK. + +************ glClear / glClearColor / glClearDepth + +The whole zbuffer and the colors are cleared in any case. The clear color +can be redefined, by *not* the initial z value. + +************ glRenderMode + +Only the modes GL_RENDER and GL_SELECT are implemented. + +************ glSelectBuffer / glInitNames / glPushName / glPopName / glLoadName + +OK. + +************ glGenTextures / glDeleteTextures / glBindTexture + +OK. These functions should be used to get the maximum performance with +TinyGL. + +************ glTexImage2D + +The function accepts only RGB UNSIGNED_BYTES bitmaps. They are +internally resized to 256x256 so you'd better use that size. No +mipmapping is implemented although it will come if asked. No borders +are implemented. + +************ glTexEnvi + +The only supported mode is GL_DECAL, although others are planned if +asked. + + +************ glTexParameteri + +The other prototypes are not implemented. Only the follwing mode are +implemented: + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + +************ glPixelStorei + +The pixels are alware byte aligned. + +************ glMaterialfv / glMaterialf / glColorMaterial + +OK. + + +************ glLightfv / glLightf / glLightModeli / glLightModelfv + +OK. The OpenGL lightening is implemented but not optimized. + + +************ glFlush + +Ignored. + +************ glHint + +Ignored. + +************ glGetIntegerv + +- only GL_VIEWPORT, GL_MAX_MODELVIEW_STACK_DEPTH, +GL_MAX_PROJECTION_STACK_DEPTH, GL_MAX_LIGHTS, GL_MAX_TEXTURE_SIZE, +GL_MAX_TEXTURE_STACK_DEPTH + +************ glGetIntegerv + +- only GL_TEXTURE_MATRIX, GL_PROJECTION_MATRIX, GL_MODELVIEW_MATRIX, +GL_LINE_WIDTH, GL_LINE_WIDTH_RANGE, GL_POINT_SIZE, GL_POINT_SIZE_RANGE + +************ glPolygonOffset + +- only API implemented. + +************ glEnableClientState, glDisableClientState, + +- No support for GL_INDEX_ARRAY_POINTER or GL_EDGE_FLAG_ARRAY_POINTER + +************ glVertexPointer, glNormalPointer, + glColorPointer, glTexureCoordPointer + +- OK + +------------------------------------------------------------------------------ + +TinyGL GLX emulation: + + +************ glXQueryExtension + +Returns always True + +************ glXChooseVisual + +Only 8 bit Pseudocolor or 16 bit Truecolor Visual are accepted. The +attribute list is ignored. + +************ glXCreateContext + +The sharing is not implemented although the code could handle it. + +************ glXDestroyContext + +OK. + +************ glXMakeCurrent + +Not all the syntax is supported yet, in particular with the 'NULL' or +'None' parameters. + + +************ glXSwapBuffers + +OK. + +************ glXWaitGL / glXWaitX + +Ignored. + + +See README.BEOS for BeOS limitations. + diff --git a/3rdparty/tinygl-0.4-ugfx/Makefile b/3rdparty/tinygl-0.4-ugfx/Makefile new file mode 100644 index 00000000..b313cddd --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/Makefile @@ -0,0 +1,15 @@ +include config.mk + +all: + ( for f in $(DIRS); do ( cd $$f ; make all ) || exit 1 ; done ) + +clean: + rm -f *~ lib/libTinyGL.a include/GL/*~ TAGS + ( for f in $(DIRS); do ( cd $$f ; make clean ; ) done ) + +install: + ( for f in $(DIRS); do ( cd $$f ; make install ; ) done ) + + +tar: + ( cd .. ; tar zcvf TinyGL-0.4.tar.gz TinyGL --exclude CVS --exclude TAGS ) diff --git a/3rdparty/tinygl-0.4-ugfx/README b/3rdparty/tinygl-0.4-ugfx/README new file mode 100644 index 00000000..82421e10 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/README @@ -0,0 +1,150 @@ +TinyGL 0.4 (c) 1997-2002 Fabrice Bellard. + +General Description: +-------------------- + +TinyGL is intended to be a very small implementation of a subset of +OpenGL* for embedded systems or games. It is a software only +implementation. Only the main OpenGL calls are implemented. All the +calls I considered not important are simply *not implemented*. + +The main strength of TinyGL is that it is fast and simple because it +has not to be exactly compatible with OpenGL. In particular, the +texture mapping and the geometrical transformations are very fast. + +The main features of TinyGL are: + +- Header compatible with OpenGL (the headers are adapted from the very good +Mesa by Brian Paul et al.) + +- Zlib-like licence for easy integration in commercial designs (read +the LICENCE file). + +- Subset of GLX for easy testing with X Window. + +- GLX like API (NGLX) to use it with NanoX in MicroWindows/NanoX. + +- Subset of BGLView under BeOS. + +- OpenGL like lightening. + +- Complete OpenGL selection mode handling for object picking. + +- 16 bit Z buffer. 16/24/32 bit RGB rendering. High speed dithering to +paletted 8 bits if needed. High speed conversion to 24 bit packed +pixel or 32 bit RGBA if needed. + +- Fast Gouraud shadding optimized for 16 bit RGB. + +- Fast texture mapping capabilities, with perspective correction and +texture objects. + +- 32 bit float only arithmetic. + +- Very small: compiled code size of about 40 kB on x86. The file + src/zfeatures.h can be used to remove some unused features from + TinyGL. + +- C sources for GCC on 32/64 bit architectures. It has been tested +succesfully on x86-Linux and sparc-Solaris. + +Examples: +--------- + +I took three simple examples from the Mesa package to test the main +functions of TinyGL. You can link them to either TinyGL, Mesa or any +other OpenGL/GLX implementation. You can also compile them with +Microwindows. + +- texobj illustrates the use of texture objects. Its shows the speed +of TinyGL in this case. + +- glutmech comes from the GLUT packages. It is much bigger and slower +because it uses the lightening. I have just included some GLU +functions and suppressed the GLUT related code to make it work. It +shows the display list handling of TinyGL in particular. You can look +at the source code to learn the keys to move the robot. The key 't' +toggles between shaded rendering and wire frame. + +- You can download and compile the VReng project to see that TinyGL +has been successfully used in a big project +(http://www-inf.enst.fr/vreng). + +Architecture: +------------- + +TinyGL is made up four main modules: + +- Mathematical routines (zmath). + +- OpenGL-like emulation (zgl). + +- Z buffer and rasterisation (zbuffer). + +- GLX interface (zglx). + +To use TinyGL in an embedded system, you should look at the GLX layer +and modify it to suit your need. Adding a more user friendly +developper layer (as in Mesa) may be useful. + +Notes - limitations: +-------------------- + +- See the file 'LIMITATIONS' to see the current functions supported by the API. + +- The multithreading could be easily implemented since no global state +is maintainted. The library gets the current context with a function +which can be modified. + +- The lightening is not very fast. I supposed that in most games the +lightening is computed by the 3D engine. + +- Some changes are needed for 64 bit pointers for the handling of +arrays of float with the GLParam union. + +- List sharing is partialy supported in the source, but not by the +current TinyGLX implementation (is it really useful ?). + +- No user clipping planes are supported. + +- No color index mode (no longer useful !) + +- The mipmapping is not implemented. + +- The perspecture correction in the mapping code does not use W but +1/Z. In any 'normal scene' it should work. + +- The resizing of the viewport in TinyGLX ensures that the width and +the height are multiples of 4. This is not optimal because some pixels +of the window may not be refreshed. + +Why ? +----- + +TinyGL was developped as a student project for a Virtual Reality +network system called VReng (see the VReng home page at +http://www-inf.enst.fr/vreng). + +At that time (January 1997), my initial project was to write my own 3D +rasterizer based on some old sources I wrote. But I realized that it +would be better to use OpenGL to work on any platform. My problem was +that I wanted to use texture mapping which was (and is still) quite +slower on many software OpenGL implementation. I could have modified +Mesa to suit my needs, but I really wanted to use my old sources for +that project. + +I finally decided to use the same syntax as OpenGL but with my own +libraries, thinking that later it could ease the porting of VReng to +OpenGL. + +Now VReng is at last compatible with OpenGL, and I managed to patch +TinyGL so that VReng can still work with it without any modifications. + +Since TinyGL may be useful for some people, especially in the world of +embedded designs, I decided to release it 'as is', otherwise, it would +have been lost on my hard disk ! + +------------------------------------------------------------------------------ +* OpenGL(R) is a registered trademark of Silicon Graphics, Inc. +------------------------------------------------------------------------------ +Fabrice Bellard. diff --git a/3rdparty/tinygl-0.4-ugfx/README.BEOS b/3rdparty/tinygl-0.4-ugfx/README.BEOS new file mode 100644 index 00000000..a146f5f7 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/README.BEOS @@ -0,0 +1,20 @@ +BeOS support for TinyGL, 1998 Peder Blekken + +I implemented (a limited version of) the BGLView class. There is +no DirectWindow support, and some other funtions are missing too, +but it should work ok for most uses. Feel free to use and modify +GLView.cpp and GLView.h in any way you desire. + +You will need to take a look in Makefile to compile the library +under BeOS. For those of you not familiar with using makefiles: too bad :) + +Also, you will probably need to remove /boot/develop/headers/be/opengl +from the BEINCLUDES environment variable. Unfortunately, this means +editing the /boot/beos/system/boot/SetupEnvironment. It might be possible +to just make sure the TinyGL path is before Be's OpenGL in the include-paths +though. But I prefer to remove /boot/develop/headers/be/opengl, since I +often use Mesa as well. It is a better to add the OpenGL include path in your +makefile; or BeIDE project if that is what you use. + +Contact me for any reason: + diff --git a/3rdparty/tinygl-0.4-ugfx/README.uGFX b/3rdparty/tinygl-0.4-ugfx/README.uGFX new file mode 100644 index 00000000..d532c544 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/README.uGFX @@ -0,0 +1,4 @@ +uGFX support for TinyGL, 2014 Andrew Hannam + +Some files have been modified to remove references to non-embedded +functions such as fprintf, exit and assert. diff --git a/3rdparty/tinygl-0.4-ugfx/config.mk b/3rdparty/tinygl-0.4-ugfx/config.mk new file mode 100644 index 00000000..5ec62ba9 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/config.mk @@ -0,0 +1,82 @@ +##################################################################### +# C compiler + +# linux +CC= gcc +CFLAGS= -g -Wall -O2 +LFLAGS= + +# for BeOS PPC +#CC= mwcc +#CFLAGS= -I. -i- +#LFLAGS= + +##################################################################### +# TinyGL configuration + +##################################################################### +# Select window API for TinyGL: + +# standard X11 GLX like API +TINYGL_USE_GLX=y + +# BEOS API +#TINYGL_USE_BEOS=y + +# Micro Windows NanoX API +#TINYGL_USE_NANOX=y + +##################################################################### +# X11 configuration (for the examples only) + +ifdef TINYGL_USE_GLX +# Linux +UI_LIBS= -L/usr/X11R6/lib -lX11 -lXext +UI_INCLUDES= +# Solaris +#UI_LIBS= -L/usr/X11/lib -lX11 -lXext -lsocket -lnsl +#UI_INCLUDES= + +UI_OBJS=x11.o +endif + +##################################################################### +# Micro windowX11 configuration (for the examples only) + +ifdef TINYGL_USE_NANOX +UI_LIBS= -lnano-X -lmwengine -lmwdrivers -lmwfonts +UI_INCLUDES= + +# X11 target for nanoX +UI_LIBS+= -L/usr/X11R6/lib -lX11 -lXext + +UI_OBJS=nanox.o +endif + +##################################################################### +# OpenGL configuration (for the examples only) + +# use TinyGL +GL_LIBS= -L../lib -lTinyGL +GL_INCLUDES= -I../include +GL_DEPS= ../lib/libTinyGL.a + +# use Mesa +#GL_LIBS= -lMesaGL +#GL_INCLUDES= +#GL_DEPS= + +# use OpenGL +#GL_LIBS= -lGL +#GL_INCLUDES= +#GL_DEPS= + +#################################################################### +# Compile and link control + +# UNIX systems +DIRS= src examples + +# BeOS +# DIRS= src BeOS + diff --git a/3rdparty/tinygl-0.4-ugfx/examples/Makefile b/3rdparty/tinygl-0.4-ugfx/examples/Makefile new file mode 100644 index 00000000..912243bb --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/examples/Makefile @@ -0,0 +1,29 @@ +include ../config.mk + +PROGS = mech texobj gears spin + +all: $(PROGS) + +clean: + rm -f core *.o *~ $(PROGS) + +mech: mech.o glu.o $(UI_OBJS) $(GL_DEPS) + $(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm + +texobj: texobj.o $(UI_OBJS) $(GL_DEPS) + $(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm + +gears: gears.o $(UI_OBJS) $(GL_DEPS) + $(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm + +spin: spin.o $(UI_OBJS) $(GL_DEPS) + $(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm + +.c.o: + $(CC) $(CFLAGS) $(GL_INCLUDES) $(UI_INCLUDES) -c $*.c + +mech.o: glu.h + +glu.o: glu.h + +ui.o: ui.h diff --git a/3rdparty/tinygl-0.4-ugfx/examples/gears.c b/3rdparty/tinygl-0.4-ugfx/examples/gears.c new file mode 100644 index 00000000..7ccf5bf2 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/examples/gears.c @@ -0,0 +1,300 @@ +/* gears.c */ + +/* + * 3-D gear wheels. This program is in the public domain. + * + * Brian Paul + */ + + +#include +#include +#include +#include + +#include +#include +#include "ui.h" + +#ifndef M_PI +# define M_PI 3.14159265 +#endif + + +/* + * Draw a gear wheel. You'll probably want to call this function when + * building a display list since we do a lot of trig here. + * + * Input: inner_radius - radius of hole at center + * outer_radius - radius at center of teeth + * width - width of gear + * teeth - number of teeth + * tooth_depth - depth of tooth + */ +static void gear( GLfloat inner_radius, GLfloat outer_radius, GLfloat width, + GLint teeth, GLfloat tooth_depth ) +{ + GLint i; + GLfloat r0, r1, r2; + GLfloat angle, da; + GLfloat u, v, len; + + r0 = inner_radius; + r1 = outer_radius - tooth_depth/2.0; + r2 = outer_radius + tooth_depth/2.0; + + da = 2.0*M_PI / teeth / 4.0; + + glShadeModel( GL_FLAT ); + + glNormal3f( 0.0, 0.0, 1.0 ); + + /* draw front face */ + glBegin( GL_QUAD_STRIP ); + for (i=0;i<=teeth;i++) { + angle = i * 2.0*M_PI / teeth; + glVertex3f( r0*cos(angle), r0*sin(angle), width*0.5 ); + glVertex3f( r1*cos(angle), r1*sin(angle), width*0.5 ); + glVertex3f( r0*cos(angle), r0*sin(angle), width*0.5 ); + glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), width*0.5 ); + } + glEnd(); + + /* draw front sides of teeth */ + glBegin( GL_QUADS ); + da = 2.0*M_PI / teeth / 4.0; + for (i=0;i1) { + /* do 'n' frames then exit */ + limit = atoi( argv[1] ) + 1; + } + else { + limit = 0; + } + + return ui_loop(argc, argv, "gears"); +} + + diff --git a/3rdparty/tinygl-0.4-ugfx/examples/glu.c b/3rdparty/tinygl-0.4-ugfx/examples/glu.c new file mode 100644 index 00000000..38561e71 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/examples/glu.c @@ -0,0 +1,261 @@ +#include +#include +#include +#include "glu.h" + + +void drawTorus(float rc, int numc, float rt, int numt) +{ + int i, j, k; + double s, t; + double x, y, z; + double pi, twopi; + + pi = 3.14159265358979323846; + twopi = 2 * pi; + + for (i = 0; i < numc; i++) { + glBegin(GL_QUAD_STRIP); + for (j = 0; j <= numt; j++) { + for (k = 1; k >= 0; k--) { + s = (i + k) % numc + 0.5; + t = j % numt; + + x = cos(t*twopi/numt) * cos(s*twopi/numc); + y = sin(t*twopi/numt) * cos(s*twopi/numc); + z = sin(s*twopi/numc); + glNormal3f(x, y, z); + + x = (rt + rc * cos(s*twopi/numc)) * cos(t*twopi/numt); + y = (rt + rc * cos(s*twopi/numc)) * sin(t*twopi/numt); + z = rc * sin(s*twopi/numc); + glVertex3f(x, y, z); + } + } + glEnd(); + } +} + +static void normal3f( GLfloat x, GLfloat y, GLfloat z ) +{ + GLdouble mag; + + mag = sqrt( x*x + y*y + z*z ); + if (mag>0.00001F) { + x /= mag; + y /= mag; + z /= mag; + } + glNormal3f( x, y, z ); +} + +void gluPerspective( GLdouble fovy, GLdouble aspect, + GLdouble zNear, GLdouble zFar ) +{ + GLdouble xmin, xmax, ymin, ymax; + + ymax = zNear * tan( fovy * M_PI / 360.0 ); + ymin = -ymax; + + xmin = ymin * aspect; + xmax = ymax * aspect; + + glFrustum( xmin, xmax, ymin, ymax, zNear, zFar ); +} + +GLUquadricObj *gluNewQuadric(void) +{ + return NULL; +} + +void gluQuadricDrawStyle(GLUquadricObj *obj, int style) +{ +} + +void gluCylinder( GLUquadricObj *qobj, + GLdouble baseRadius, GLdouble topRadius, GLdouble height, + GLint slices, GLint stacks ) +{ + GLdouble da, r, dr, dz; + GLfloat z, nz, nsign; + GLint i, j; + GLfloat du = 1.0 / slices; + GLfloat dv = 1.0 / stacks; + GLfloat tcx = 0.0, tcy = 0.0; + + nsign = 1.0; + + da = 2.0*M_PI / slices; + dr = (topRadius-baseRadius) / stacks; + dz = height / stacks; + nz = (baseRadius-topRadius) / height; /* Z component of normal vectors */ + + for (i=0;i=0;j--) { + theta = (j==slices) ? 0.0 : j * dtheta; + x = -sin(theta) * sin(rho); + y = cos(theta) * sin(rho); + z = nsign * cos(rho); + if (normals) glNormal3f( x*nsign, y*nsign, z*nsign ); + glTexCoord2f(s,1-t); + s -= ds; + glVertex3f( x*radius, y*radius, z*radius ); + } + glEnd(); +} diff --git a/3rdparty/tinygl-0.4-ugfx/examples/glu.h b/3rdparty/tinygl-0.4-ugfx/examples/glu.h new file mode 100644 index 00000000..8e4bbdf6 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/examples/glu.h @@ -0,0 +1,23 @@ + +void gluPerspective( GLdouble fovy, GLdouble aspect, + GLdouble zNear, GLdouble zFar ); + +typedef struct { + int draw_style; +} GLUquadricObj; + +#define GLU_LINE 0 + +GLUquadricObj *gluNewQuadric(void); +void gluQuadricDrawStyle(GLUquadricObj *obj, int style); + +void gluSphere(GLUquadricObj *qobj, + float radius,int slices,int stacks); +void gluCylinder( GLUquadricObj *qobj, + GLdouble baseRadius, GLdouble topRadius, GLdouble height, + GLint slices, GLint stacks ); +void gluDisk( GLUquadricObj *qobj, + GLdouble innerRadius, GLdouble outerRadius, + GLint slices, GLint loops ); + +void drawTorus(float rc, int numc, float rt, int numt); diff --git a/3rdparty/tinygl-0.4-ugfx/examples/mech.c b/3rdparty/tinygl-0.4-ugfx/examples/mech.c new file mode 100644 index 00000000..f071ee39 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/examples/mech.c @@ -0,0 +1,1753 @@ +/** +* program : glutmech V1.1 +* author : Simon Parkinson-Bates. +* E-mail : sapb@yallara.cs.rmit.edu.au +* Copyright Simon Parkinson-Bates. +* "source if freely avaliable to anyone to copy as long as they +* acknowledge me in their work." +* +* Funtional features +* ------------------ +* * online menu system avaliable by pressing left mouse button +* * online cascading help system avaliable, providing information on +* the several key strokes and what they do. +* * animation sequence coded which makes the mech walk through an +* environment. Shadows will soon be added to make it look +* more realistic. +* * menu control to view mech in wireframe or sold mode. +* * various key strokes avaliable to control idependently the mechs +* many joints. +* * various key strokes avaliable to view mech and environment from +* different angles +* * various key strokes avaliable to alter positioning of the single +* light source. +* +* +* Program features +* ---------------- +* * uses double buffering +* * uses display lists +* * uses glut to manage windows, callbacks, and online menu. +* * uses glpolygonfill() to maintain colors in wireframe and solid +* mode. +* +**/ + +/* start of compilation conditions */ +#define SPHERE +#define COLOR +#define LIGHT +#define TORSO +#define HIP +#define SHOULDER +#define UPPER_ARM +#define LOWER_ARM +#define ROCKET_POD +#define UPPER_LEG +#define LOWER_LEG +#define NO_NORM +#define ANIMATION +#define DRAW_MECH +#define DRAW_ENVIRO +#define MOVE_LIGHT +/* end of compilation conditions */ + +/* start various header files needed */ +#include +#include +#include + +#define GLUT +#define GLUT_KEY +#define GLUT_SPEC +#include +#include +#include "glu.h" +#include "ui.h" + +/* end of header files */ + +/* start of display list definitions */ +#define SOLID_MECH_TORSO 1 +#define SOLID_MECH_HIP 2 +#define SOLID_MECH_SHOULDER 3 +#define SOLID_MECH_UPPER_ARM 4 +#define SOLID_MECH_FOREARM 5 +#define SOLID_MECH_UPPER_LEG 6 +#define SOLID_MECH_FOOT 7 +#define SOLID_MECH_ROCKET 8 +#define SOLID_MECH_VULCAN 9 +#define SOLID_ENVIRO 10 +/* end of display list definitions */ + +/* start of motion rate variables */ +#define ANKLE_RATE 3 +#define HEEL_RATE 3 +#define ROTATE_RATE 10 +#define TILT_RATE 10 +#define ELBOW_RATE 2 +#define SHOULDER_RATE 5 +#define LAT_RATE 5 +#define CANNON_RATE 40 +#define UPPER_LEG_RATE 3 +#define UPPER_LEG_RATE_GROIN 10 +#define LIGHT_TURN_RATE 10 +#define VIEW_TURN_RATE 10 +/* end of motion rate variables */ + +/* start of motion variables */ +#ifndef PI +#define PI 3.141592654 +#endif + +char leg = 0; + +int shoulder1 = 0, shoulder2 = 0, shoulder3 = 0, shoulder4 = 0, lat1 = 20, lat2 = 20, + elbow1 = 0, elbow2 = 0, pivot = 0, tilt = 10, ankle1 = 0, ankle2 = 0, heel1 = 0, + heel2 = 0, hip11 = 0, hip12 = 10, hip21 = 0, hip22 = 10, fire = 0, solid_part = 0, + anim = 0, turn = 0, turn1 = 0, lightturn = 0, lightturn1 = 0; + +float elevation = 0.0, distance = 0.0, frame = 3.0 + /* foot1v[] = {} foot2v[] = {} */ ; + +/* end of motion variables */ + +/* start of material definitions */ +#ifdef LIGHT +GLfloat mat_specular[] = +{0.628281, 0.555802, 0.366065, 1.0}; +GLfloat mat_ambient[] = +{0.24725, 0.1995, 0.0745, 1.0}; +GLfloat mat_diffuse[] = +{0.75164, 0.60648, 0.22648, 1.0}; +GLfloat mat_shininess[] = +{128.0 * 0.4}; + +GLfloat mat_specular2[] = +{0.508273, 0.508273, 0.508373, 1.0}; +GLfloat mat_ambient2[] = +{0.19225, 0.19225, 0.19225, 1.0}; +GLfloat mat_diffuse2[] = +{0.50754, 0.50754, 0.50754, 1.0}; +GLfloat mat_shininess2[] = +{128.0 * 0.6}; + +GLfloat mat_specular3[] = +{0.296648, 0.296648, 0.296648, 1.0}; +GLfloat mat_ambient3[] = +{0.25, 0.20725, 0.20725, 1.0}; +GLfloat mat_diffuse3[] = +{1, 0.829, 0.829, 1.0}; +GLfloat mat_shininess3[] = +{128.0 * 0.088}; + +GLfloat mat_specular4[] = +{0.633, 0.727811, 0.633, 1.0}; +GLfloat mat_ambient4[] = +{0.0215, 0.1745, 0.0215, 1.0}; +GLfloat mat_diffuse4[] = +{0.07568, 0.61424, 0.07568, 1.0}; +GLfloat mat_shininess4[] = +{128 * 0.6}; + +GLfloat mat_specular5[] = +{0.60, 0.60, 0.50, 1.0}; +GLfloat mat_ambient5[] = +{0.0, 0.0, 0.0, 1.0}; +GLfloat mat_diffuse5[] = +{0.5, 0.5, 0.0, 1.0}; +GLfloat mat_shininess5[] = +{128.0 * 0.25}; + +#endif +/* end of material definitions */ + +/* start of the body motion functions */ +void +Heel1Add(void) +{ + heel1 = (heel1 + HEEL_RATE) % 360; +} + +void +Heel1Subtract(void) +{ + heel1 = (heel1 - HEEL_RATE) % 360; +} + +void +Heel2Add(void) +{ + heel2 = (heel2 + HEEL_RATE) % 360; +} + +void +Heel2Subtract(void) +{ + heel2 = (heel2 - HEEL_RATE) % 360; +} + +void +Ankle1Add(void) +{ + ankle1 = (ankle1 + ANKLE_RATE) % 360; +} + +void +Ankle1Subtract(void) +{ + ankle1 = (ankle1 - ANKLE_RATE) % 360; +} + +void +Ankle2Add(void) +{ + ankle2 = (ankle2 + ANKLE_RATE) % 360; +} + +void +Ankle2Subtract(void) +{ + ankle2 = (ankle2 - ANKLE_RATE) % 360; +} + +void +RotateAdd(void) +{ + pivot = (pivot + ROTATE_RATE) % 360; +} + +void +RotateSubtract(void) +{ + pivot = (pivot - ROTATE_RATE) % 360; +} + +void +MechTiltSubtract(void) +{ + tilt = (tilt - TILT_RATE) % 360; +} + +void +MechTiltAdd(void) +{ + tilt = (tilt + TILT_RATE) % 360; +} + +void +elbow1Add(void) +{ + elbow1 = (elbow1 + ELBOW_RATE) % 360; +} + +void +elbow1Subtract(void) +{ + elbow1 = (elbow1 - ELBOW_RATE) % 360; +} + +void +elbow2Add(void) +{ + elbow2 = (elbow2 + ELBOW_RATE) % 360; +} + +void +elbow2Subtract(void) +{ + elbow2 = (elbow2 - ELBOW_RATE) % 360; +} + +void +shoulder1Add(void) +{ + shoulder1 = (shoulder1 + SHOULDER_RATE) % 360; +} + +void +shoulder1Subtract(void) +{ + shoulder1 = (shoulder1 - SHOULDER_RATE) % 360; +} + +void +shoulder2Add(void) +{ + shoulder2 = (shoulder2 + SHOULDER_RATE) % 360; +} + +void +shoulder2Subtract(void) +{ + shoulder2 = (shoulder2 - SHOULDER_RATE) % 360; +} + +void +shoulder3Add(void) +{ + shoulder3 = (shoulder3 + SHOULDER_RATE) % 360; +} + +void +shoulder3Subtract(void) +{ + shoulder3 = (shoulder3 - SHOULDER_RATE) % 360; +} + +void +shoulder4Add(void) +{ + shoulder4 = (shoulder4 + SHOULDER_RATE) % 360; +} + +void +shoulder4Subtract(void) +{ + shoulder4 = (shoulder4 - SHOULDER_RATE) % 360; +} + +void +lat1Raise(void) +{ + lat1 = (lat1 + LAT_RATE) % 360; +} + +void +lat1Lower(void) +{ + lat1 = (lat1 - LAT_RATE) % 360; +} + +void +lat2Raise(void) +{ + lat2 = (lat2 + LAT_RATE) % 360; +} + +void +lat2Lower(void) +{ + lat2 = (lat2 - LAT_RATE) % 360; +} + +void +FireCannon(void) +{ + fire = (fire + CANNON_RATE) % 360; +} + +void +RaiseLeg1Forward(void) +{ + hip11 = (hip11 + UPPER_LEG_RATE) % 360; +} + +void +LowerLeg1Backwards(void) +{ + hip11 = (hip11 - UPPER_LEG_RATE) % 360; +} + +void +RaiseLeg1Outwards(void) +{ + hip12 = (hip12 + UPPER_LEG_RATE_GROIN) % 360; +} + +void +LowerLeg1Inwards(void) +{ + hip12 = (hip12 - UPPER_LEG_RATE_GROIN) % 360; +} + +void +RaiseLeg2Forward(void) +{ + hip21 = (hip21 + UPPER_LEG_RATE) % 360; +} + +void +LowerLeg2Backwards(void) +{ + hip21 = (hip21 - UPPER_LEG_RATE) % 360; +} + +void +RaiseLeg2Outwards(void) +{ + hip22 = (hip22 + UPPER_LEG_RATE_GROIN) % 360; +} + +void +LowerLeg2Inwards(void) +{ + hip22 = (hip22 - UPPER_LEG_RATE_GROIN) % 360; +} + +/* end of body motion functions */ + +/* start of light source position functions */ +void +TurnRight(void) +{ + turn = (turn - VIEW_TURN_RATE) % 360; +} + +void +TurnLeft(void) +{ + turn = (turn + VIEW_TURN_RATE) % 360; +} + +void +TurnForwards(void) +{ + turn1 = (turn1 - VIEW_TURN_RATE) % 360; +} + +void +TurnBackwards(void) +{ + turn1 = (turn1 + VIEW_TURN_RATE) % 360; +} + +void +LightTurnRight(void) +{ + lightturn = (lightturn + LIGHT_TURN_RATE) % 360; +} + +void +LightTurnLeft(void) +{ + lightturn = (lightturn - LIGHT_TURN_RATE) % 360; +} + +void +LightForwards(void) +{ + lightturn1 = (lightturn1 + LIGHT_TURN_RATE) % 360; +} + +void +LightBackwards(void) +{ + lightturn1 = (lightturn1 - LIGHT_TURN_RATE) % 360; +} + +/* end of light source position functions */ + +/* start of geometric shape functions */ +void +Box(float width, float height, float depth, char solid) +{ + char i, j = 0; + float x = width / 2.0, y = height / 2.0, z = depth / 2.0; + + for (i = 0; i < 4; i++) { + glRotatef(90.0, 0.0, 0.0, 1.0); + if (j) { + if (!solid) + glBegin(GL_LINE_LOOP); + else + glBegin(GL_QUADS); + glNormal3f(-1.0, 0.0, 0.0); + glVertex3f(-x, y, z); + glVertex3f(-x, -y, z); + glVertex3f(-x, -y, -z); + glVertex3f(-x, y, -z); + glEnd(); + if (solid) { + glBegin(GL_TRIANGLES); + glNormal3f(0.0, 0.0, 1.0); + glVertex3f(0.0, 0.0, z); + glVertex3f(-x, y, z); + glVertex3f(-x, -y, z); + glNormal3f(0.0, 0.0, -1.0); + glVertex3f(0.0, 0.0, -z); + glVertex3f(-x, -y, -z); + glVertex3f(-x, y, -z); + glEnd(); + } + j = 0; + } else { + if (!solid) + glBegin(GL_LINE_LOOP); + else + glBegin(GL_QUADS); + glNormal3f(-1.0, 0.0, 0.0); + glVertex3f(-y, x, z); + glVertex3f(-y, -x, z); + glVertex3f(-y, -x, -z); + glVertex3f(-y, x, -z); + glEnd(); + if (solid) { + glBegin(GL_TRIANGLES); + glNormal3f(0.0, 0.0, 1.0); + glVertex3f(0.0, 0.0, z); + glVertex3f(-y, x, z); + glVertex3f(-y, -x, z); + glNormal3f(0.0, 0.0, -1.0); + glVertex3f(0.0, 0.0, -z); + glVertex3f(-y, -x, -z); + glVertex3f(-y, x, -z); + glEnd(); + } + j = 1; + } + } +} + +void +Octagon(float side, float height, char solid) +{ + char j; + float x = sin(0.785398163) * side, y = side / 2.0, z = height / 2.0, c; + + c = x + y; + for (j = 0; j < 8; j++) { + glTranslatef(-c, 0.0, 0.0); + if (!solid) + glBegin(GL_LINE_LOOP); + else + glBegin(GL_QUADS); + glNormal3f(-1.0, 0.0, 0.0); + glVertex3f(0.0, -y, z); + glVertex3f(0.0, y, z); + glVertex3f(0.0, y, -z); + glVertex3f(0.0, -y, -z); + glEnd(); + glTranslatef(c, 0.0, 0.0); + if (solid) { + glBegin(GL_TRIANGLES); + glNormal3f(0.0, 0.0, 1.0); + glVertex3f(0.0, 0.0, z); + glVertex3f(-c, -y, z); + glVertex3f(-c, y, z); + glNormal3f(0.0, 0.0, -1.0); + glVertex3f(0.0, 0.0, -z); + glVertex3f(-c, y, -z); + glVertex3f(-c, -y, -z); + glEnd(); + } + glRotatef(45.0, 0.0, 0.0, 1.0); + } +} + +/* end of geometric shape functions */ +#ifdef NORM +void +Normalize(float v[3]) +{ + GLfloat d = sqrt(v[1] * v[1] + v[2] * v[2] + v[3] * v[3]); + + if (d == 0.0) { + printf("zero length vector"); + return; + } + v[1] /= d; + v[2] /= d; + v[3] /= d; +} + +void +NormXprod(float v1[3], float v2[3], float v[3], float out[3]) +{ + GLint i, j; + GLfloat length; + + out[0] = v1[1] * v2[2] - v1[2] * v2[1]; + out[1] = v1[2] * v2[0] - v1[0] * v2[2]; + out[2] = v1[0] * v2[1] - v1[1] * v2[0]; + Normalize(out); +} + +#endif + +void +SetMaterial(GLfloat spec[], GLfloat amb[], GLfloat diff[], GLfloat shin[]) +{ + + glMaterialfv(GL_FRONT, GL_SPECULAR, spec); + glMaterialfv(GL_FRONT, GL_SHININESS, shin); + glMaterialfv(GL_FRONT, GL_AMBIENT, amb); + glMaterialfv(GL_FRONT, GL_DIFFUSE, diff); +} + +void +MechTorso(char solid) +{ + glNewList(SOLID_MECH_TORSO, GL_COMPILE); +#ifdef LIGHT + SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); +#endif + glColor3f(1.0, 1.0, 0.0); + Box(1.0, 1.0, 3.0, solid); + glTranslatef(0.75, 0.0, 0.0); +#ifdef LIGHT + SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); +#endif + glColor3f(0.5, 0.5, 0.5); + Box(0.5, 0.6, 2.0, solid); + glTranslatef(-1.5, 0.0, 0.0); + Box(0.5, 0.6, 2.0, solid); + glTranslatef(0.75, 0.0, 0.0); + glEndList(); +} + +void +MechHip(char solid) +{ + int i; + GLUquadricObj *hip[2]; + + glNewList(SOLID_MECH_HIP, GL_COMPILE); +#ifdef LIGHT + SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); +#endif + glColor3f(1.0, 1.0, 0.0); + Octagon(0.7, 0.5, solid); +#ifdef SPHERE + for (i = 0; i < 2; i++) { + if (i) + glScalef(-1.0, 1.0, 1.0); + glTranslatef(1.0, 0.0, 0.0); + hip[i] = gluNewQuadric(); +#ifdef LIGHT + SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); +#endif + glColor3f(0.5, 0.5, 0.5); + if (!solid) + gluQuadricDrawStyle(hip[i], GLU_LINE); + gluSphere(hip[0], 0.2, 16, 16); + glTranslatef(-1.0, 0.0, 0.0); + } + glScalef(-1.0, 1.0, 1.0); +#endif + glEndList(); +} + +void +Shoulder(char solid) +{ + GLUquadricObj *deltoid = gluNewQuadric(); + + glNewList(SOLID_MECH_SHOULDER, GL_COMPILE); +#ifdef LIGHT + SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); +#endif + glColor3f(1.0, 1.0, 0.0); + Box(1.0, 0.5, 0.5, solid); + glTranslatef(0.9, 0.0, 0.0); +#ifdef LIGHT + SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); +#endif + glColor3f(0.5, 0.5, 0.5); +#ifdef SPHERE + if (!solid) + gluQuadricDrawStyle(deltoid, GLU_LINE); + gluSphere(deltoid, 0.6, 16, 16); +#endif + glTranslatef(-0.9, 0.0, 0.0); + glEndList(); +} + +void +UpperArm(char solid) +{ + GLUquadricObj *upper = gluNewQuadric(); + GLUquadricObj *joint[2]; + GLUquadricObj *joint1[2]; + int i; + + glNewList(SOLID_MECH_UPPER_ARM, GL_COMPILE); +#ifdef LIGHT + SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); +#endif + glColor3f(1.0, 1.0, 0.0); + Box(1.0, 2.0, 1.0, solid); + glTranslatef(0.0, -0.95, 0.0); + glRotatef(90.0, 1.0, 0.0, 0.0); +#ifdef LIGHT + SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); +#endif + glColor3f(0.5, 0.5, 0.5); + if (!solid) + gluQuadricDrawStyle(upper, GLU_LINE); + gluCylinder(upper, 0.4, 0.4, 1.5, 16, 10); +#ifdef LIGHT + SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); +#endif + glColor3f(1.0, 1.0, 0.0); + glRotatef(-90.0, 1.0, 0.0, 0.0); + glTranslatef(-0.4, -1.85, 0.0); + glRotatef(90.0, 0.0, 1.0, 0.0); + for (i = 0; i < 2; i++) { + joint[i] = gluNewQuadric(); + if (!solid) + gluQuadricDrawStyle(joint[i], GLU_LINE); + if (i) + gluCylinder(joint[i], 0.5, 0.5, 0.8, 16, 10); + else + gluCylinder(joint[i], 0.2, 0.2, 0.8, 16, 10); + } + for (i = 0; i < 2; i++) { + if (i) + glScalef(-1.0, 1.0, 1.0); + joint1[i] = gluNewQuadric(); + if (!solid) + gluQuadricDrawStyle(joint1[i], GLU_LINE); + if (i) + glTranslatef(0.0, 0.0, 0.8); + gluDisk(joint1[i], 0.2, 0.5, 16, 10); + if (i) + glTranslatef(0.0, 0.0, -0.8); + } + glScalef(-1.0, 1.0, 1.0); + glRotatef(-90.0, 0.0, 1.0, 0.0); + glTranslatef(0.4, 2.9, 0.0); + glEndList(); +} + +void +VulcanGun(char solid) +{ + int i; + GLUquadricObj *Barrel[5]; + GLUquadricObj *BarrelFace[5]; + GLUquadricObj *Barrel2[5]; + GLUquadricObj *Barrel3[5]; + GLUquadricObj *BarrelFace2[5]; + GLUquadricObj *Mount = gluNewQuadric(); + GLUquadricObj *Mount_face = gluNewQuadric(); + + glNewList(SOLID_MECH_VULCAN, GL_COMPILE); + +#ifdef LIGHT + SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); +#endif + glColor3f(0.5, 0.5, 0.5); + + if (!solid) { + gluQuadricDrawStyle(Mount, GLU_LINE); + gluQuadricDrawStyle(Mount_face, GLU_LINE); + } + gluCylinder(Mount, 0.5, 0.5, 0.5, 16, 10); + glTranslatef(0.0, 0.0, 0.5); + gluDisk(Mount_face, 0.0, 0.5, 16, 10); + + for (i = 0; i < 5; i++) { + Barrel[i] = gluNewQuadric(); + BarrelFace[i] = gluNewQuadric(); + BarrelFace2[i] = gluNewQuadric(); + Barrel2[i] = gluNewQuadric(); + Barrel3[i] = gluNewQuadric(); + glRotatef(72.0, 0.0, 0.0, 1.0); + glTranslatef(0.0, 0.3, 0.0); + if (!solid) { + gluQuadricDrawStyle(Barrel[i], GLU_LINE); + gluQuadricDrawStyle(BarrelFace[i], GLU_LINE); + gluQuadricDrawStyle(BarrelFace2[i], GLU_LINE); + gluQuadricDrawStyle(Barrel2[i], GLU_LINE); + gluQuadricDrawStyle(Barrel3[i], GLU_LINE); + } + gluCylinder(Barrel[i], 0.15, 0.15, 2.0, 16, 10); + gluCylinder(Barrel3[i], 0.06, 0.06, 2.0, 16, 10); + glTranslatef(0.0, 0.0, 2.0); + gluDisk(BarrelFace[i], 0.1, 0.15, 16, 10); + gluCylinder(Barrel2[i], 0.1, 0.1, 0.1, 16, 5); + glTranslatef(0.0, 0.0, 0.1); + gluDisk(BarrelFace2[i], 0.06, 0.1, 16, 5); + glTranslatef(0.0, -0.3, -2.1); + } + glEndList(); +} + +void +ForeArm(char solid) +{ + char i; + + glNewList(SOLID_MECH_FOREARM, GL_COMPILE); +#ifdef LIGHT + SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); +#endif + glColor3f(1.0, 1.0, 0.0); + for (i = 0; i < 5; i++) { + glTranslatef(0.0, -0.1, -0.15); + Box(0.6, 0.8, 0.2, solid); + glTranslatef(0.0, 0.1, -0.15); + Box(0.4, 0.6, 0.1, solid); + } + glTranslatef(0.0, 0.0, 2.45); + Box(1.0, 1.0, 2.0, solid); + glTranslatef(0.0, 0.0, -1.0); + glEndList(); +} + +void +UpperLeg(char solid) +{ + int i; + GLUquadricObj *Hamstring = gluNewQuadric(); + GLUquadricObj *Knee = gluNewQuadric(); + GLUquadricObj *joint[2]; + + glNewList(SOLID_MECH_UPPER_LEG, GL_COMPILE); +#ifdef LIGHT + SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); +#endif + glColor3f(1.0, 1.0, 0.0); + if (!solid) { + gluQuadricDrawStyle(Hamstring, GLU_LINE); + gluQuadricDrawStyle(Knee, GLU_LINE); + } + glTranslatef(0.0, -1.0, 0.0); + Box(0.4, 1.0, 0.7, solid); + glTranslatef(0.0, -0.65, 0.0); + for (i = 0; i < 5; i++) { + Box(1.2, 0.3, 1.2, solid); + glTranslatef(0.0, -0.2, 0.0); + Box(1.0, 0.1, 1.0, solid); + glTranslatef(0.0, -0.2, 0.0); + } + glTranslatef(0.0, -0.15, -0.4); + Box(2.0, 0.5, 2.0, solid); + glTranslatef(0.0, -0.3, -0.2); + glRotatef(90.0, 1.0, 0.0, 0.0); +#ifdef LIGHT + SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); +#endif + glColor3f(0.5, 0.5, 0.5); + gluCylinder(Hamstring, 0.6, 0.6, 3.0, 16, 10); +#ifdef LIGHT + SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); +#endif + glColor3f(1.0, 1.0, 0.0); + glRotatef(-90.0, 1.0, 0.0, 0.0); + glTranslatef(0.0, -1.5, 1.0); + Box(1.5, 3.0, 0.5, solid); + glTranslatef(0.0, -1.75, -0.8); + Box(2.0, 0.5, 2.0, solid); + glTranslatef(0.0, -0.9, -0.85); +#ifdef LIGHT + SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); +#endif + glColor3f(0.5, 0.5, 0.5); + gluCylinder(Knee, 0.8, 0.8, 1.8, 16, 10); + for (i = 0; i < 2; i++) { + if (i) + glScalef(-1.0, 1.0, 1.0); + joint[i] = gluNewQuadric(); + if (!solid) + gluQuadricDrawStyle(joint[i], GLU_LINE); + if (i) + glTranslatef(0.0, 0.0, 1.8); + gluDisk(joint[i], 0.0, 0.8, 16, 10); + if (i) + glTranslatef(0.0, 0.0, -1.8); + } + glScalef(-1.0, 1.0, 1.0); + glEndList(); +} + +void +Foot(char solid) +{ + + glNewList(SOLID_MECH_FOOT, GL_COMPILE); +#ifdef LIGHT + SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); +#endif + glColor3f(0.5, 0.5, 0.5); + glRotatef(90.0, 1.0, 0.0, 0.0); + Octagon(1.5, 0.6, solid); + glRotatef(-90.0, 1.0, 0.0, 0.0); + glEndList(); +} + +void +LowerLeg(char solid) +{ + float k, l; + GLUquadricObj *ankle = gluNewQuadric(); + GLUquadricObj *ankle_face[2],*joints; + +#ifdef LIGHT + SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); +#endif + glColor3f(1.0, 1.0, 0.0); + for (k = 0.0; k < 2.0; k++) { + for (l = 0.0; l < 2.0; l++) { + glPushMatrix(); + glTranslatef(k, 0.0, l); +#ifdef LIGHT + SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); +#endif + glColor3f(1.0, 1.0, 0.0); + Box(1.0, 0.5, 1.0, solid); + glTranslatef(0.0, -0.45, 0.0); +#ifdef LIGHT + SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); +#endif + glColor3f(0.5, 0.5, 0.5); +#ifdef SPHERE + joints = gluNewQuadric(); + if(!solid)gluQuadricDrawStyle(joints, GLU_LINE); + gluSphere(joints,0.2, 16, 16); + free(joints); +#endif + if (leg) + glRotatef((GLfloat) heel1, 1.0, 0.0, 0.0); + else + glRotatef((GLfloat) heel2, 1.0, 0.0, 0.0); + /* glTranslatef(0.0, -0.2, 0.0); */ + glTranslatef(0.0, -1.7, 0.0); +#ifdef LIGHT + SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); +#endif + glColor3f(1.0, 1.0, 0.0); + Box(0.25, 3.0, 0.25, solid); + glTranslatef(0.0, -1.7, 0.0); +#ifdef LIGHT + SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); +#endif + glColor3f(0.5, 0.5, 0.5); +#ifdef SPHERE + joints = gluNewQuadric(); + if(!solid)gluQuadricDrawStyle(joints, GLU_LINE); + gluSphere(joints, 0.2, 16, 16); +#endif + if (leg) + glRotatef((GLfloat) - heel1, 1.0, 0.0, 0.0); + else + glRotatef((GLfloat) - heel2, 1.0, 0.0, 0.0); + glTranslatef(0.0, -0.45, 0.0); +#ifdef LIGHT + SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); +#endif + glColor3f(1.0, 1.0, 0.0); + Box(1.0, 0.5, 1.0, solid); + if (!k && !l) { + int j; + + glTranslatef(-0.4, -0.8, 0.5); + if (leg) + glRotatef((GLfloat) ankle1, 1.0, 0.0, 0.0); + else + glRotatef((GLfloat) ankle2, 1.0, 0.0, 0.0); + glRotatef(90.0, 0.0, 1.0, 0.0); + if (!solid) + gluQuadricDrawStyle(ankle, GLU_LINE); + gluCylinder(ankle, 0.8, 0.8, 1.8, 16, 10); + for (j = 0; j < 2; j++) { + ankle_face[j] = gluNewQuadric(); + if (!solid) + gluQuadricDrawStyle(ankle_face[j], GLU_LINE); + if (j) { + glScalef(-1.0, 1.0, 1.0); + glTranslatef(0.0, 0.0, 1.8); + } + gluDisk(ankle_face[j], 0.0, 0.8, 16, 10); + if (j) + glTranslatef(0.0, 0.0, -1.8); + } + glScalef(-1.0, 1.0, 1.0); + glRotatef(-90.0, 0.0, 1.0, 0.0); + glTranslatef(0.95, -0.8, 0.0); + glCallList(SOLID_MECH_FOOT); + } + glPopMatrix(); + } + } +} + +void +RocketPod(char solid) +{ + + int i, j, k = 0; + GLUquadricObj *rocket[6]; + GLUquadricObj *rocket1[6]; + + glNewList(SOLID_MECH_ROCKET, GL_COMPILE); +#ifdef LIGHT + SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); +#endif + glColor3f(0.5, 0.5, 0.5); + glScalef(0.4, 0.4, 0.4); + glRotatef(45.0, 0.0, 0.0, 1.0); + glTranslatef(1.0, 0.0, 0.0); + Box(2.0, 0.5, 3.0, solid); + glTranslatef(1.0, 0.0, 0.0); + glRotatef(45.0, 0.0, 0.0, 1.0); + glTranslatef(0.5, 0.0, 0.0); + Box(1.2, 0.5, 3.0, solid); + glTranslatef(2.1, 0.0, 0.0); + glRotatef(-90.0, 0.0, 0.0, 1.0); +#ifdef LIGHT + SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); +#endif + glColor3f(1.0, 1.0, 0.0); + Box(2.0, 3.0, 4.0, solid); + glTranslatef(-0.5, -1.0, 1.3); + for (i = 0; i < 2; i++) { + for (j = 0; j < 3; j++) { + rocket[k] = gluNewQuadric(); + rocket1[k] = gluNewQuadric(); + if (!solid) { + gluQuadricDrawStyle(rocket[k], GLU_LINE); + gluQuadricDrawStyle(rocket1[k], GLU_LINE); + } + glTranslatef(i, j, 0.6); +#ifdef LIGHT + SetMaterial(mat_specular3, mat_ambient3, mat_diffuse3, mat_shininess3); +#endif + glColor3f(1.0, 1.0, 1.0); + gluCylinder(rocket[k], 0.4, 0.4, 0.3, 16, 10); + glTranslatef(0.0, 0.0, 0.3); +#ifdef LIGHT + SetMaterial(mat_specular4, mat_ambient4, mat_diffuse4, mat_shininess4); +#endif + glColor3f(0.0, 1.0, 0.0); + gluCylinder(rocket1[k], 0.4, 0.0, 0.5, 16, 10); + k++; + glTranslatef(-i, -j, -0.9); + } + } + glEndList(); +} + +void +Enviro(char solid) +{ + + int i, j; + + glNewList(SOLID_ENVIRO, GL_COMPILE); + SetMaterial(mat_specular4, mat_ambient4, mat_diffuse4, mat_shininess4); + glColor3f(0.0, 1.0, 0.0); + Box(20.0, 0.5, 30.0, solid); + + SetMaterial(mat_specular4, mat_ambient3, mat_diffuse2, mat_shininess); + glColor3f(0.6, 0.6, 0.6); + glTranslatef(0.0, 0.0, -10.0); + for (j = 0; j < 6; j++) { + for (i = 0; i < 2; i++) { + if (i) + glScalef(-1.0, 1.0, 1.0); + glTranslatef(10.0, 4.0, 0.0); + Box(4.0, 8.0, 2.0, solid); + glTranslatef(0.0, -1.0, -3.0); + Box(4.0, 6.0, 2.0, solid); + glTranslatef(-10.0, -3.0, 3.0); + } + glScalef(-1.0, 1.0, 1.0); + glTranslatef(0.0, 0.0, 5.0); + } + + glEndList(); +} + +void +Toggle(void) +{ + if (solid_part) + solid_part = 0; + else + solid_part = 1; +} + +void +disable(void) +{ + glDisable(GL_LIGHTING); + glDisable(GL_DEPTH_TEST); + glDisable(GL_NORMALIZE); + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); +} + +void +lighting(void) +{ + + GLfloat position[] = + {0.0, 0.0, 2.0, 1.0}; + +#ifdef MOVE_LIGHT + glRotatef((GLfloat) lightturn1, 1.0, 0.0, 0.0); + glRotatef((GLfloat) lightturn, 0.0, 1.0, 0.0); + glRotatef(0.0, 1.0, 0.0, 0.0); +#endif + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glEnable(GL_NORMALIZE); + /* glEnable(GL_FLAT); */ + /* glDepthFunc(GL_LESS); */ + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + + glLightfv(GL_LIGHT0, GL_POSITION, position); + glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 80.0); + + glTranslatef(0.0, 0.0, 2.0); + glDisable(GL_LIGHTING); + Box(0.1, 0.1, 0.1, 0); + glEnable(GL_LIGHTING); + /* glEnable(GL_CULL_FACE); */ +} + +void +DrawMech(void) +{ + int i, j; + + glScalef(0.5, 0.5, 0.5); + glPushMatrix(); + glTranslatef(0.0, -0.75, 0.0); + glRotatef((GLfloat) tilt, 1.0, 0.0, 0.0); + + glRotatef(90.0, 1.0, 0.0, 0.0); +#ifdef HIP + glCallList(SOLID_MECH_HIP); +#endif + glRotatef(-90.0, 1.0, 0.0, 0.0); + + glTranslatef(0.0, 0.75, 0.0); + glPushMatrix(); + glRotatef((GLfloat) pivot, 0.0, 1.0, 0.0); + glPushMatrix(); +#ifdef TORSO + glCallList(SOLID_MECH_TORSO); +#endif + glPopMatrix(); + glPushMatrix(); + glTranslatef(0.5, 0.5, 0.0); +#ifdef ROCKET_POD + glCallList(SOLID_MECH_ROCKET); +#endif + glPopMatrix(); + for (i = 0; i < 2; i++) { + glPushMatrix(); + if (i) + glScalef(-1.0, 1.0, 1.0); + glTranslatef(1.5, 0.0, 0.0); +#ifdef SHOULDER + glCallList(SOLID_MECH_SHOULDER); +#endif + glTranslatef(0.9, 0.0, 0.0); + if (i) { + glRotatef((GLfloat) lat1, 0.0, 0.0, 1.0); + glRotatef((GLfloat) shoulder1, 1.0, 0.0, 0.0); + glRotatef((GLfloat) shoulder3, 0.0, 1.0, 0.0); + } else { + glRotatef((GLfloat) lat2, 0.0, 0.0, 1.0); + glRotatef((GLfloat) shoulder2, 1.0, 0.0, 0.0); + glRotatef((GLfloat) shoulder4, 0.0, 1.0, 0.0); + } + glTranslatef(0.0, -1.4, 0.0); +#ifdef UPPER_ARM + glCallList(SOLID_MECH_UPPER_ARM); +#endif + glTranslatef(0.0, -2.9, 0.0); + if (i) + glRotatef((GLfloat) elbow1, 1.0, 0.0, 0.0); + else + glRotatef((GLfloat) elbow2, 1.0, 0.0, 0.0); + glTranslatef(0.0, -0.9, -0.2); +#ifdef LOWER_ARM + glCallList(SOLID_MECH_FOREARM); + glPushMatrix(); + glTranslatef(0.0, 0.0, 2.0); + glRotatef((GLfloat) fire, 0.0, 0.0, 1.0); + glCallList(SOLID_MECH_VULCAN); + glPopMatrix(); +#endif + glPopMatrix(); + } + glPopMatrix(); + + glPopMatrix(); + + for (j = 0; j < 2; j++) { + glPushMatrix(); + if (j) { + glScalef(-0.5, 0.5, 0.5); + leg = 1; + } else { + glScalef(0.5, 0.5, 0.5); + leg = 0; + } + glTranslatef(2.0, -1.5, 0.0); + if (j) { + glRotatef((GLfloat) hip11, 1.0, 0.0, 0.0); + glRotatef((GLfloat) hip12, 0.0, 0.0, 1.0); + } else { + glRotatef((GLfloat) hip21, 1.0, 0.0, 0.0); + glRotatef((GLfloat) hip22, 0.0, 0.0, 1.0); + } + glTranslatef(0.0, 0.3, 0.0); +#ifdef UPPER_LEG + glPushMatrix(); + glCallList(SOLID_MECH_UPPER_LEG); + glPopMatrix(); +#endif + glTranslatef(0.0, -8.3, -0.4); + if (j) + glRotatef((GLfloat) - hip12, 0.0, 0.0, 1.0); + else + glRotatef((GLfloat) - hip22, 0.0, 0.0, 1.0); + glTranslatef(-0.5, -0.85, -0.5); +#ifdef LOWER_LEG + LowerLeg(1); +#endif + glPopMatrix(); + } +} + +void +display(void) +{ + glClearColor(0.0, 0.0, 0.0, 0.0); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glEnable(GL_DEPTH_TEST); + + glPushMatrix(); + glRotatef((GLfloat) turn, 0.0, 1.0, 0.0); + glRotatef((GLfloat) turn1, 1.0, 0.0, 0.0); +#ifdef LIGHT + if (solid_part) { + glPushMatrix(); + lighting(); + glPopMatrix(); + } else + disable(); +#endif +#ifdef DRAW_MECH + glPushMatrix(); + glTranslatef(0.0, elevation, 0.0); + DrawMech(); + glPopMatrix(); +#endif +#ifdef DRAW_ENVIRO + glPushMatrix(); + if (distance >= 20.136) + distance = 0.0; + glTranslatef(0.0, -5.0, -distance); + glCallList(SOLID_ENVIRO); + glTranslatef(0.0, 0.0, 10.0); + glCallList(SOLID_ENVIRO); + glPopMatrix(); +#endif + glPopMatrix(); + glFlush(); + tkSwapBuffers(); +} + +void +init(void) +{ + char i = 1; + +#ifdef LIGHT + SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); +#endif + glEnable(GL_DEPTH_TEST); + MechTorso(i); + MechHip(i); + Shoulder(i); + RocketPod(i); + UpperArm(i); + ForeArm(i); + UpperLeg(i); + Foot(i); + VulcanGun(i); + Enviro(i); +} + +void +reshape(int w, int h) +{ + glViewport(0, 0, w, h); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + gluPerspective(65.0, (GLfloat) w / (GLfloat) h, 1.0, 20.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0.0, 1.2, -5.5); /* viewing transform */ +} + +#ifdef ANIMATION +void +animation_walk(void) +{ + float angle; + static int step; + + if (step == 0 || step == 2) { + /* for(frame=3.0; frame<=21.0; frame=frame+3.0){ */ + if (frame >= 0.0 && frame <= 21.0) { + if (frame == 0.0) + frame = 3.0; + angle = (180 / PI) * (acos(((cos((PI / 180) * frame) * 2.043) + 1.1625) / 3.2059)); + if (frame > 0) { + elevation = -(3.2055 - (cos((PI / 180) * angle) * 3.2055)); + } else + elevation = 0.0; + if (step == 0) { + hip11 = -(frame * 1.7); + if (1.7 * frame > 15) + heel1 = frame * 1.7; + heel2 = 0; + ankle1 = frame * 1.7; + if (frame > 0) + hip21 = angle; + else + hip21 = 0; + ankle2 = -hip21; + shoulder1 = frame * 1.5; + shoulder2 = -frame * 1.5; + elbow1 = frame; + elbow2 = -frame; + } else { + hip21 = -(frame * 1.7); + if (1.7 * frame > 15) + heel2 = frame * 1.7; + heel1 = 0; + ankle2 = frame * 1.7; + if (frame > 0) + hip11 = angle; + else + hip11 = 0; + ankle1 = -hip11; + shoulder1 = -frame * 1.5; + shoulder2 = frame * 1.5; + elbow1 = -frame; + elbow2 = frame; + } + if (frame == 21) + step++; + if (frame < 21) + frame = frame + 3.0; + } + } + if (step == 1 || step == 3) { + /* for(x=21.0; x>=0.0; x=x-3.0){ */ + if (frame <= 21.0 && frame >= 0.0) { + angle = (180 / PI) * (acos(((cos((PI / 180) * frame) * 2.043) + 1.1625) / 3.2029)); + if (frame > 0) + elevation = -(3.2055 - (cos((PI / 180) * angle) * 3.2055)); + else + elevation = 0.0; + if (step == 1) { + elbow2 = hip11 = -frame; + elbow1 = heel1 = frame; + heel2 = 15; + ankle1 = frame; + if (frame > 0) + hip21 = angle; + else + hip21 = 0; + ankle2 = -hip21; + shoulder1 = 1.5 * frame; + shoulder2 = -frame * 1.5; + } else { + elbow1 = hip21 = -frame; + elbow2 = heel2 = frame; + heel1 = 15; + ankle2 = frame; + if (frame > 0) + hip11 = angle; + else + hip11 = 0; + ankle1 = -hip11; + shoulder1 = -frame * 1.5; + shoulder2 = frame * 1.5; + } + if (frame == 0.0) + step++; + if (frame > 0) + frame = frame - 3.0; + } + } + if (step == 4) + step = 0; + distance += 0.1678; +} + +void +animation(void) +{ + animation_walk(); +} + +#endif + +GLenum key(int key, GLenum mask) +{ + + int i = 0; + + switch (key) { + /* start arm control functions */ + case 'q':{ + shoulder2Subtract(); + i++; + } + break; + case 'a':{ + shoulder2Add(); + i++; + } + break; + case 'w':{ + shoulder1Subtract(); + i++; + } + break; + case 's':{ + shoulder1Add(); + i++; + } + break; + case '2':{ + shoulder3Add(); + i++; + } + break; + case '1':{ + shoulder4Add(); + i++; + } + break; + case '4':{ + shoulder3Subtract(); + i++; + } + break; + case '3':{ + shoulder4Subtract(); + i++; + } + break; + + case 'z':{ + lat2Raise(); + i++; + } + break; + case 'Z':{ + lat2Lower(); + i++; + } + break; + case 'x':{ + lat1Raise(); + i++; + } + break; + case 'X':{ + lat1Lower(); + i++; + } + break; + + case 'A':{ + elbow2Add(); + i++; + } + break; + case 'Q':{ + elbow2Subtract(); + i++; + } + break; + case 'S':{ + elbow1Add(); + i++; + } + break; + case 'W':{ + elbow1Subtract(); + i++; + } + break; + /* end of arm control functions */ + + /* start of torso control functions */ + case 'd':{ + RotateAdd(); + i++; + } + break; + case 'g':{ + RotateSubtract(); + i++; + } + break; + case 'r':{ + MechTiltAdd(); + i++; + } + break; + case 'f':{ + MechTiltSubtract(); + i++; + } + break; + /* end of torso control functions */ + + /* start of leg control functions */ + case 'h':{ + RaiseLeg2Forward(); + i++; + } + break; + case 'y':{ + LowerLeg2Backwards(); + i++; + } + break; + case 'Y':{ + RaiseLeg2Outwards(); + i++; + } + break; + case 'H':{ + LowerLeg2Inwards(); + i++; + } + break; + + case 'j':{ + RaiseLeg1Forward(); + i++; + } + break; + case 'u':{ + LowerLeg1Backwards(); + i++; + } + break; + case 'U':{ + RaiseLeg1Outwards(); + i++; + } + break; + case 'J':{ + LowerLeg1Inwards(); + i++; + } + break; + + case 'N':{ + Heel2Add(); + i++; + } + break; + case 'n':{ + Heel2Subtract(); + i++; + } + break; + case 'M':{ + Heel1Add(); + i++; + } + break; + case 'm':{ + Heel1Subtract(); + i++; + } + break; + + case 'k':{ + Ankle2Add(); + i++; + } + break; + case 'K':{ + Ankle2Subtract(); + i++; + } + break; + case 'l':{ + Ankle1Add(); + i++; + } + break; + case 'L':{ + Ankle1Subtract(); + i++; + } + break; + /* end of leg control functions */ + + /* start of light source position functions */ + case 'p':{ + LightTurnRight(); + i++; + } + break; + case 'i':{ + LightTurnLeft(); + i++; + } + break; + case 'o':{ + LightForwards(); + i++; + } + break; + case '9':{ + LightBackwards(); + i++; + } + break; + /* end of light source position functions */ + + /* start of misc functions */ + case 't': + Toggle(); + break; + + case KEY_LEFT: + TurnLeft(); + break; + case KEY_RIGHT: + TurnRight(); + break; + case KEY_UP: + TurnBackwards(); + break; + case KEY_DOWN: + TurnForwards(); + break; + + case ' ': + FireCannon(); + } + return 0; +} + +void printHelp(void) +{ + printf("at the shoulders:"); + printf("forward : q,w"); + printf("backwards : a,s"); + printf("outwards : z,x"); + printf("inwards : Z,X"); +#if 0 + glut_menu[6] = glutCreateMenu(null_select); + printf("upwards : Q,W\n"); + printf("downwards : A,S\n"); + printf("outwards : 1,2\n"); + printf("inwards : 3,4\n"); + + glut_menu[1] = glutCreateMenu(null_select); + printf(" : Page_up\n"); + + glut_menu[8] = glutCreateMenu(null_select); + printf("forward : y,u\n"); + printf("backwards : h.j\n"); + printf("outwards : Y,U\n"); + printf("inwards : H,J\n"); + + glut_menu[9] = glutCreateMenu(null_select); + printf("forward : n,m\n"); + printf("backwards : N,M\n"); + + glut_menu[9] = glutCreateMenu(null_select); + printf("forward : n,m\n"); + printf("backwards : N,M\n"); + + glut_menu[10] = glutCreateMenu(null_select); + printf("toes up : K,L\n"); + printf("toes down : k,l\n"); + + glut_menu[11] = glutCreateMenu(null_select); + printf("right : right arrow\n"); + printf("left : left arrow\n"); + printf("down : up arrow\n"); + printf("up : down arrow\n"); + + glut_menu[12] = glutCreateMenu(null_select); + printf("right : p\n"); + printf("left : i\n"); + printf("up : 9\n"); + printf("down : o\n"); + + glut_menu[4] = glutCreateMenu(NULL); + glutAddSubMenu("at the elbows?", glut_menu[6]); + + glut_menu[7] = glutCreateMenu(NULL); + glutAddSubMenu("at the hip? ", glut_menu[8]); + glutAddSubMenu("at the knees?", glut_menu[9]); + glutAddSubMenu("at the ankles? ", glut_menu[10]); + + printf("turn left : d\n"); + printf("turn right : g\n"); + + glut_menu[3] = glutCreateMenu(null_select); + printf("tilt backwards : f\n"); + printf("tilt forwards : r\n"); + + glut_menu[0] = glutCreateMenu(NULL); + glutAddSubMenu("move the arms.. ", glut_menu[4]); + glutAddSubMenu("fire the vulcan guns?", glut_menu[1]); + glutAddSubMenu("move the legs.. ", glut_menu[7]); + glutAddSubMenu("move the torso?", glut_menu[2]); + glutAddSubMenu("move the hip?", glut_menu[3]); + glutAddSubMenu("rotate the scene..", glut_menu[11]); +#ifdef MOVE_LIGHT + glutAddSubMenu("rotate the light source..", glut_menu[12]); +#endif + + glutCreateMenu(menu_select); +#ifdef ANIMATION + printf("Start Walk", 1); + printf("Stop Walk", 2); +#endif + printf("Toggle Wireframe", 3); + glutAddSubMenu("How do I ..", glut_menu[0]); + printfy("Quit", 4); + glutAttachMenu(GLUT_LEFT_BUTTON); + glutAttachMenu(GLUT_RIGHT_BUTTON); +#endif +} + +void idle( void ) +{ + /* animate the mech */ + + animation(); + + /* draw the Mech */ + + display(); +} + +/* #define PROFILE */ + +#ifdef PROFILE +extern int count_triangles; +#endif + +// #define LINUX_TEST_FLOAT + +#ifdef LINUX_TEST_FLOAT +#include +#endif + +int +main(int argc, char **argv) +{ +#ifdef LINUX_TEST_FLOAT + /* for debuging floating point errors under Linux */ + __setfpucw ( 0x1372 ); +#endif + + Toggle(); + + return ui_loop(argc, argv, "mech"); +} diff --git a/3rdparty/tinygl-0.4-ugfx/examples/nanox.c b/3rdparty/tinygl-0.4-ugfx/examples/nanox.c new file mode 100644 index 00000000..14e5d4f1 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/examples/nanox.c @@ -0,0 +1,113 @@ +/* + * Demonstration program for Nano-X graphics. + */ +#include +#include +#include +#define MWINCLUDECOLORS +#include +#include +#include +#include "ui.h" + +static GR_WINDOW_ID w1; /* id for large window */ +static GR_GC_ID gc1; /* graphics context for text */ + +void errorcatcher(); /* routine to handle errors */ + +void tkSwapBuffers(void) +{ + nglXSwapBuffers(w1); +} + +int +ui_loop(int argc,char **argv, const char *name) +{ + GR_EVENT event; /* current event */ + GR_IMAGE_ID id = 0; + NGLXContext cx; + int width, height, k; + + if (GrOpen() < 0) { + fprintf(stderr, "cannot open graphics\n"); + exit(1); + } + + width = 400; + height = 300; + + GrSetErrorHandler(errorcatcher); + + w1 = GrNewWindow(GR_ROOT_WINDOW_ID, 10, 10, width, height, 4, BLACK, WHITE); + + GrSelectEvents(w1, GR_EVENT_MASK_CLOSE_REQ|GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_DOWN); + + GrMapWindow(w1); + + gc1 = GrNewGC(); + + GrSetGCForeground(gc1, WHITE); + + cx = nglXCreateContext(NULL, 0); + nglXMakeCurrent(w1, cx); + + init(); + reshape(width, height); + + while (1) { + GrCheckNextEvent(&event); + switch(event.type) { + case GR_EVENT_TYPE_CLOSE_REQ: + GrFreeImage(id); + GrClose(); + exit(0); + case GR_EVENT_TYPE_EXPOSURE: + break; + case GR_EVENT_TYPE_KEY_DOWN: + { + GR_EVENT_KEYSTROKE *kp = &event.keystroke; + /* XXX: nanoX special keys are totally bugged ! */ + switch(kp->ch) { + case 81: + k = KEY_LEFT; + break; + case 83: + k = KEY_RIGHT; + break; + case 82: + k = KEY_UP; + break; + case 84: + k = KEY_DOWN; + break; + default: + k = kp->ch; + break; + } + key(k, 0); + } + break; + default: + idle(); + break; + } + } + + return 0; +} + + +/* + * Here on an unrecoverable error. + */ +void +errorcatcher(code, name, id) + GR_ERROR code; /* error code */ + GR_FUNC_NAME name; /* function name which failed */ + GR_ID id; /* resource id */ +{ + GrClose(); + fprintf(stderr, "DEMO ERROR: code %d, function %s, resource id %d\n", + code, name, id); + exit(1); +} diff --git a/3rdparty/tinygl-0.4-ugfx/examples/spin.c b/3rdparty/tinygl-0.4-ugfx/examples/spin.c new file mode 100644 index 00000000..339bf003 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/examples/spin.c @@ -0,0 +1,160 @@ +/* spin.c */ + + +/* + * Spinning box. This program is in the public domain. + * + * Brian Paul + */ + + +#include +#include + +#include +#include +#include "ui.h" + + + + +static GLfloat Xrot, Xstep; +static GLfloat Yrot, Ystep; +static GLfloat Zrot, Zstep; +static GLfloat Step = 5.0; +static GLfloat Scale = 1.0; +static GLuint Object; + + + + +static GLuint make_object( void ) +{ + GLuint list; + + list = glGenLists( 1 ); + + glNewList( list, GL_COMPILE ); + + glBegin( GL_LINE_LOOP ); + glColor3f( 1.0, 1.0, 1.0 ); + glVertex3f( 1.0, 0.5, -0.4 ); + glColor3f( 1.0, 0.0, 0.0 ); + glVertex3f( 1.0, -0.5, -0.4 ); + glColor3f( 0.0, 1.0, 0.0 ); + glVertex3f( -1.0, -0.5, -0.4 ); + glColor3f( 0.0, 0.0, 1.0 ); + glVertex3f( -1.0, 0.5, -0.4 ); + glEnd(); + + glColor3f( 1.0, 1.0, 1.0 ); + + glBegin( GL_LINE_LOOP ); + glVertex3f( 1.0, 0.5, 0.4 ); + glVertex3f( 1.0, -0.5, 0.4 ); + glVertex3f( -1.0, -0.5, 0.4 ); + glVertex3f( -1.0, 0.5, 0.4 ); + glEnd(); + + glBegin( GL_LINES ); + glVertex3f( 1.0, 0.5, -0.4 ); glVertex3f( 1.0, 0.5, 0.4 ); + glVertex3f( 1.0, -0.5, -0.4 ); glVertex3f( 1.0, -0.5, 0.4 ); + glVertex3f( -1.0, -0.5, -0.4 ); glVertex3f( -1.0, -0.5, 0.4 ); + glVertex3f( -1.0, 0.5, -0.4 ); glVertex3f( -1.0, 0.5, 0.4 ); + glEnd(); + + + glEndList(); + + return list; +} + + + +void reshape( int width, int height ) +{ + glViewport(0, 0, (GLint)width, (GLint)height); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 15.0 ); + glMatrixMode(GL_MODELVIEW); +} + + +GLenum key(int k, GLenum mask) +{ + switch (k) { + case KEY_ESCAPE: + exit(0); + } + return GL_FALSE; +} + + +void draw( void ) +{ + glClear( GL_COLOR_BUFFER_BIT ); + + glPushMatrix(); + + glTranslatef( 0.0, 0.0, -10.0 ); + glScalef( Scale, Scale, Scale ); + if (Xstep) { + glRotatef( Xrot, 1.0, 0.0, 0.0 ); + } + else if (Ystep) { + glRotatef( Yrot, 0.0, 1.0, 0.0 ); + } + else { + glRotatef( Zrot, 0.0, 0.0, 1.0 ); + } + + glCallList( Object ); + + glPopMatrix(); + + glFlush(); + tkSwapBuffers(); +} + + +void idle( void ) +{ + Xrot += Xstep; + Yrot += Ystep; + Zrot += Zstep; + + if (Xrot>=360.0) { + Xrot = Xstep = 0.0; + Ystep = Step; + } + else if (Yrot>=360.0) { + Yrot = Ystep = 0.0; + Zstep = Step; + } + else if (Zrot>=360.0) { + Zrot = Zstep = 0.0; + Xstep = Step; + } + draw(); +} + +void init(void) +{ + Object = make_object(); + glCullFace( GL_BACK ); +/* glEnable( GL_CULL_FACE );*/ + glDisable( GL_DITHER ); + glShadeModel( GL_FLAT ); +/* glEnable( GL_DEPTH_TEST ); */ + + Xrot = Yrot = Zrot = 0.0; + Xstep = Step; + Ystep = Zstep = 0.0; +} + + +int main( int argc, char *argv[] ) +{ + return ui_loop(argc, argv, "spin"); +} diff --git a/3rdparty/tinygl-0.4-ugfx/examples/texobj.c b/3rdparty/tinygl-0.4-ugfx/examples/texobj.c new file mode 100644 index 00000000..913d35aa --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/examples/texobj.c @@ -0,0 +1,193 @@ +/* + * Example of using the 1.1 texture object functions. + * Also, this demo utilizes Mesa's fast texture map path. + * + * Brian Paul June 1996 + */ + +#include +#include +#include +#include + +#include +#include +#include "ui.h" + +static GLuint TexObj[2]; +static GLfloat Angle = 0.0f; + +static int cnt=0,v=0; + +void +draw(void) +{ + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glColor3f(1.0, 1.0, 1.0); + + /* draw first polygon */ + glPushMatrix(); + glTranslatef(-1.0, 0.0, 0.0); + glRotatef(Angle, 0.0, 0.0, 1.0); + glBindTexture(GL_TEXTURE_2D, TexObj[v]); + + glEnable(GL_TEXTURE_2D); + glBegin(GL_QUADS); + glTexCoord2f(0.0, 0.0); + glVertex2f(-1.0, -1.0); + glTexCoord2f(1.0, 0.0); + glVertex2f(1.0, -1.0); + glTexCoord2f(1.0, 1.0); + glVertex2f(1.0, 1.0); + glTexCoord2f(0.0, 1.0); + glVertex2f(-1.0, 1.0); + glEnd(); + glDisable(GL_TEXTURE_2D); + glPopMatrix(); + + /* draw second polygon */ + glPushMatrix(); + glTranslatef(1.0, 0.0, 0.0); + glRotatef(Angle - 90.0, 0.0, 1.0, 0.0); + + glBindTexture(GL_TEXTURE_2D, TexObj[1-v]); + + glEnable(GL_TEXTURE_2D); + glBegin(GL_QUADS); + glTexCoord2f(0.0, 0.0); + glVertex2f(-1.0, -1.0); + glTexCoord2f(1.0, 0.0); + glVertex2f(1.0, -1.0); + glTexCoord2f(1.0, 1.0); + glVertex2f(1.0, 1.0); + glTexCoord2f(0.0, 1.0); + glVertex2f(-1.0, 1.0); + glEnd(); + glDisable(GL_TEXTURE_2D); + + glPopMatrix(); + + tkSwapBuffers(); +} + + +/* new window size or exposure */ +void +reshape(int width, int height) +{ + glViewport(0, 0, (GLint) width, (GLint) height); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + /* glOrtho( -3.0, 3.0, -3.0, 3.0, -10.0, 10.0 ); */ + glFrustum(-2.0, 2.0, -2.0, 2.0, 6.0, 20.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0.0, 0.0, -8.0); +} + + +void bind_texture(int texobj,int image) +{ + static int width = 8, height = 8; + static int color[2][3]={ + {255,0,0}, + {0,255,0}, + }; + GLubyte tex[64][3]; + static GLubyte texchar[2][8*8] = { + { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0}, + { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 2, 0, 0, 0, + 0, 0, 2, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, + 0, 0, 2, 2, 2, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0}}; + + int i,j; + + glBindTexture(GL_TEXTURE_2D, texobj); + + /* red on white */ + for (i = 0; i < height; i++) { + for (j = 0; j < width; j++) { + int p = i * width + j; + if (texchar[image][(height - i - 1) * width + j]) { + tex[p][0] = color[image][0]; + tex[p][1] = color[image][1]; + tex[p][2] = color[image][2]; + } else { + tex[p][0] = 255; + tex[p][1] = 255; + tex[p][2] = 255; + } + } + } + glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, + GL_RGB, GL_UNSIGNED_BYTE, tex); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + /* end of texture object */ +} + + + +void +init(void) +{ + glEnable(GL_DEPTH_TEST); + + /* Setup texturing */ + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); + glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); + + /* generate texture object IDs */ + glGenTextures(2, TexObj); + bind_texture(TexObj[0],0); + bind_texture(TexObj[1],1); + +} + +void +idle(void) +{ + + Angle += 2.0; + + if (++cnt==5) { + cnt=0; + v=!v; + } + draw(); +} + +/* change view angle, exit upon ESC */ +GLenum key(int k, GLenum mask) +{ + switch (k) { + case 'q': + case KEY_ESCAPE: + exit(0); + } + return GL_FALSE; +} + +int main(int argc, char **argv) +{ + return ui_loop(argc, argv, "texobj"); +} + + diff --git a/3rdparty/tinygl-0.4-ugfx/examples/ui.h b/3rdparty/tinygl-0.4-ugfx/examples/ui.h new file mode 100644 index 00000000..8814566e --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/examples/ui.h @@ -0,0 +1,17 @@ +/* + * tk like ui + */ +void draw( void ); +void idle( void ); +GLenum key(int k, GLenum mask); +void reshape( int width, int height ); +void init( void ); +int ui_loop(int argc, char **argv, const char *name); +void tkSwapBuffers(void); + +#define KEY_UP 0xe000 +#define KEY_DOWN 0xe001 +#define KEY_LEFT 0xe002 +#define KEY_RIGHT 0xe003 +#define KEY_ESCAPE 0xe004 + diff --git a/3rdparty/tinygl-0.4-ugfx/examples/x11.c b/3rdparty/tinygl-0.4-ugfx/examples/x11.c new file mode 100644 index 00000000..13913f51 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/examples/x11.c @@ -0,0 +1,139 @@ +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include "ui.h" + + +#ifndef M_PI +# define M_PI 3.14159265 +#endif + +static int attributeList[] = { GLX_RGBA, GLX_DOUBLEBUFFER, None }; + +static Bool WaitForNotify(Display *d, XEvent *e, char *arg) +{ + return (e->type == MapNotify) && (e->xmap.window == (Window)arg); +} + +Display *dpy; +Window win; + +void tkSwapBuffers(void) +{ + glXSwapBuffers(dpy,win); +} + +int ui_loop(int argc, char **argv, const char *name) +{ + XVisualInfo *vi; + Colormap cmap; + XSetWindowAttributes swa; + XSizeHints hint; + GLXContext cx; + XEvent event; + int k, width, height; + char buf[80]; + XEvent xev; + KeySym keysym; + XComposeStatus status; + + /* get a connection */ + dpy = XOpenDisplay(NULL); + if (dpy == NULL) { + fprintf(stderr,"Could not open X display\n"); + exit(1); + } + + /* get an appropriate visual */ + vi = glXChooseVisual(dpy, DefaultScreen(dpy), attributeList); + if (vi == NULL) { + fprintf(stderr, "No suitable visual for glx\n"); + exit(1); + } + + /* create a GLX context */ + cx = glXCreateContext(dpy, vi, 0, GL_TRUE); + + /* create a color map */ + cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen), + vi->visual, AllocNone); + + /* create a window */ + width = 400; + height = 300; + hint.x = 0; + hint.y = 0; + hint.width = width; + hint.height = height; + hint.flags = PPosition | PSize; + swa.colormap = cmap; + swa.border_pixel = 0; + swa.event_mask = StructureNotifyMask; + win = XCreateWindow(dpy, RootWindow(dpy, vi->screen), 0, 0, width, height, + 0, vi->depth, InputOutput, vi->visual, + CWBorderPixel|CWColormap|CWEventMask, &swa); + XSetStandardProperties (dpy, win, name, name, None, NULL, 0, &hint); + + XMapWindow(dpy, win); + XIfEvent(dpy, &event, WaitForNotify, (char*)win); + XSelectInput(dpy, win, KeyPressMask | StructureNotifyMask | ExposureMask); + + /* connect the context to the window */ + glXMakeCurrent(dpy, win, cx); + + init(); + reshape(width, height); + + while (1) { + if (XPending(dpy) > 0) { + XNextEvent(dpy,&xev); + switch(xev.type) { + case KeyPress: + XLookupString((XKeyEvent *)&xev,buf,80,&keysym,&status); + switch(keysym) { + case XK_Up: + k = KEY_UP; + break; + case XK_Down: + k = KEY_DOWN; + break; + case XK_Left: + k = KEY_LEFT; + break; + case XK_Right: + k = KEY_RIGHT; + break; + case XK_Escape: + k = KEY_ESCAPE; + break; + default: + k = keysym; + } + key(k, 0); + break; + case ConfigureNotify: + { + int width,height; + width = xev.xconfigure.width; + height = xev.xconfigure.height; + glXWaitX(); + reshape(width, height); + } + break; + } + } else { + idle(); + } + } + return 0; +} + + diff --git a/3rdparty/tinygl-0.4-ugfx/include/GL/gl.h b/3rdparty/tinygl-0.4-ugfx/include/GL/gl.h new file mode 100644 index 00000000..24035047 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/include/GL/gl.h @@ -0,0 +1,838 @@ +/* + * The following constants come from Mesa + */ +#ifndef GL_H +#define GL_H + +#define GL_VERSION_1_1 1 + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + /* Boolean values */ + GL_FALSE = 0, + GL_TRUE = 1, + + /* Data types */ + GL_BYTE = 0x1400, + GL_UNSIGNED_BYTE = 0x1401, + GL_SHORT = 0x1402, + GL_UNSIGNED_SHORT = 0x1403, + GL_INT = 0x1404, + GL_UNSIGNED_INT = 0x1405, + GL_FLOAT = 0x1406, + GL_DOUBLE = 0x140A, + GL_2_BYTES = 0x1407, + GL_3_BYTES = 0x1408, + GL_4_BYTES = 0x1409, + + /* Primitives */ + GL_LINES = 0x0001, + GL_POINTS = 0x0000, + GL_LINE_STRIP = 0x0003, + GL_LINE_LOOP = 0x0002, + GL_TRIANGLES = 0x0004, + GL_TRIANGLE_STRIP = 0x0005, + GL_TRIANGLE_FAN = 0x0006, + GL_QUADS = 0x0007, + GL_QUAD_STRIP = 0x0008, + GL_POLYGON = 0x0009, + GL_EDGE_FLAG = 0x0B43, + + /* Vertex Arrays */ + GL_VERTEX_ARRAY = 0x8074, + GL_NORMAL_ARRAY = 0x8075, + GL_COLOR_ARRAY = 0x8076, + GL_INDEX_ARRAY = 0x8077, + GL_TEXTURE_COORD_ARRAY = 0x8078, + GL_EDGE_FLAG_ARRAY = 0x8079, + GL_VERTEX_ARRAY_SIZE = 0x807A, + GL_VERTEX_ARRAY_TYPE = 0x807B, + GL_VERTEX_ARRAY_STRIDE = 0x807C, + GL_VERTEX_ARRAY_COUNT = 0x807D, + GL_NORMAL_ARRAY_TYPE = 0x807E, + GL_NORMAL_ARRAY_STRIDE = 0x807F, + GL_NORMAL_ARRAY_COUNT = 0x8080, + GL_COLOR_ARRAY_SIZE = 0x8081, + GL_COLOR_ARRAY_TYPE = 0x8082, + GL_COLOR_ARRAY_STRIDE = 0x8083, + GL_COLOR_ARRAY_COUNT = 0x8084, + GL_INDEX_ARRAY_TYPE = 0x8085, + GL_INDEX_ARRAY_STRIDE = 0x8086, + GL_INDEX_ARRAY_COUNT = 0x8087, + GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088, + GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089, + GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A, + GL_TEXTURE_COORD_ARRAY_COUNT = 0x808B, + GL_EDGE_FLAG_ARRAY_STRIDE = 0x808C, + GL_EDGE_FLAG_ARRAY_COUNT = 0x808D, + GL_VERTEX_ARRAY_POINTER = 0x808E, + GL_NORMAL_ARRAY_POINTER = 0x808F, + GL_COLOR_ARRAY_POINTER = 0x8090, + GL_INDEX_ARRAY_POINTER = 0x8091, + GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092, + GL_EDGE_FLAG_ARRAY_POINTER = 0x8093, + GL_V2F = 0x2A20, + GL_V3F = 0x2A21, + GL_C4UB_V2F = 0x2A22, + GL_C4UB_V3F = 0x2A23, + GL_C3F_V3F = 0x2A24, + GL_N3F_V3F = 0x2A25, + GL_C4F_N3F_V3F = 0x2A26, + GL_T2F_V3F = 0x2A27, + GL_T4F_V4F = 0x2A28, + GL_T2F_C4UB_V3F = 0x2A29, + GL_T2F_C3F_V3F = 0x2A2A, + GL_T2F_N3F_V3F = 0x2A2B, + GL_T2F_C4F_N3F_V3F = 0x2A2C, + GL_T4F_C4F_N3F_V4F = 0x2A2D, + + /* Matrix Mode */ + GL_MATRIX_MODE = 0x0BA0, + GL_MODELVIEW = 0x1700, + GL_PROJECTION = 0x1701, + GL_TEXTURE = 0x1702, + + /* Points */ + GL_POINT_SMOOTH = 0x0B10, + GL_POINT_SIZE = 0x0B11, + GL_POINT_SIZE_GRANULARITY = 0x0B13, + GL_POINT_SIZE_RANGE = 0x0B12, + + /* Lines */ + GL_LINE_SMOOTH = 0x0B20, + GL_LINE_STIPPLE = 0x0B24, + GL_LINE_STIPPLE_PATTERN = 0x0B25, + GL_LINE_STIPPLE_REPEAT = 0x0B26, + GL_LINE_WIDTH = 0x0B21, + GL_LINE_WIDTH_GRANULARITY = 0x0B23, + GL_LINE_WIDTH_RANGE = 0x0B22, + + /* Polygons */ + GL_POINT = 0x1B00, + GL_LINE = 0x1B01, + GL_FILL = 0x1B02, + GL_CCW = 0x0901, + GL_CW = 0x0900, + GL_FRONT = 0x0404, + GL_BACK = 0x0405, + GL_CULL_FACE = 0x0B44, + GL_CULL_FACE_MODE = 0x0B45, + GL_POLYGON_SMOOTH = 0x0B41, + GL_POLYGON_STIPPLE = 0x0B42, + GL_FRONT_FACE = 0x0B46, + GL_POLYGON_MODE = 0x0B40, + GL_POLYGON_OFFSET_FACTOR = 0x3038, + GL_POLYGON_OFFSET_UNITS = 0x2A00, + GL_POLYGON_OFFSET_POINT = 0x2A01, + GL_POLYGON_OFFSET_LINE = 0x2A02, + GL_POLYGON_OFFSET_FILL = 0x8037, + + /* Display Lists */ + GL_COMPILE = 0x1300, + GL_COMPILE_AND_EXECUTE = 0x1301, + GL_LIST_BASE = 0x0B32, + GL_LIST_INDEX = 0x0B33, + GL_LIST_MODE = 0x0B30, + + /* Depth buffer */ + GL_NEVER = 0x0200, + GL_LESS = 0x0201, + GL_GEQUAL = 0x0206, + GL_LEQUAL = 0x0203, + GL_GREATER = 0x0204, + GL_NOTEQUAL = 0x0205, + GL_EQUAL = 0x0202, + GL_ALWAYS = 0x0207, + GL_DEPTH_TEST = 0x0B71, + GL_DEPTH_BITS = 0x0D56, + GL_DEPTH_CLEAR_VALUE = 0x0B73, + GL_DEPTH_FUNC = 0x0B74, + GL_DEPTH_RANGE = 0x0B70, + GL_DEPTH_WRITEMASK = 0x0B72, + GL_DEPTH_COMPONENT = 0x1902, + + /* Lighting */ + GL_LIGHTING = 0x0B50, + GL_LIGHT0 = 0x4000, + GL_LIGHT1 = 0x4001, + GL_LIGHT2 = 0x4002, + GL_LIGHT3 = 0x4003, + GL_LIGHT4 = 0x4004, + GL_LIGHT5 = 0x4005, + GL_LIGHT6 = 0x4006, + GL_LIGHT7 = 0x4007, + GL_SPOT_EXPONENT = 0x1205, + GL_SPOT_CUTOFF = 0x1206, + GL_CONSTANT_ATTENUATION = 0x1207, + GL_LINEAR_ATTENUATION = 0x1208, + GL_QUADRATIC_ATTENUATION = 0x1209, + GL_AMBIENT = 0x1200, + GL_DIFFUSE = 0x1201, + GL_SPECULAR = 0x1202, + GL_SHININESS = 0x1601, + GL_EMISSION = 0x1600, + GL_POSITION = 0x1203, + GL_SPOT_DIRECTION = 0x1204, + GL_AMBIENT_AND_DIFFUSE = 0x1602, + GL_COLOR_INDEXES = 0x1603, + GL_LIGHT_MODEL_TWO_SIDE = 0x0B52, + GL_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51, + GL_LIGHT_MODEL_AMBIENT = 0x0B53, + GL_FRONT_AND_BACK = 0x0408, + GL_SHADE_MODEL = 0x0B54, + GL_FLAT = 0x1D00, + GL_SMOOTH = 0x1D01, + GL_COLOR_MATERIAL = 0x0B57, + GL_COLOR_MATERIAL_FACE = 0x0B55, + GL_COLOR_MATERIAL_PARAMETER = 0x0B56, + GL_NORMALIZE = 0x0BA1, + + /* User clipping planes */ + GL_CLIP_PLANE0 = 0x3000, + GL_CLIP_PLANE1 = 0x3001, + GL_CLIP_PLANE2 = 0x3002, + GL_CLIP_PLANE3 = 0x3003, + GL_CLIP_PLANE4 = 0x3004, + GL_CLIP_PLANE5 = 0x3005, + + /* Accumulation buffer */ + GL_ACCUM_RED_BITS = 0x0D58, + GL_ACCUM_GREEN_BITS = 0x0D59, + GL_ACCUM_BLUE_BITS = 0x0D5A, + GL_ACCUM_ALPHA_BITS = 0x0D5B, + GL_ACCUM_CLEAR_VALUE = 0x0B80, + GL_ACCUM = 0x0100, + GL_ADD = 0x0104, + GL_LOAD = 0x0101, + GL_MULT = 0x0103, + GL_RETURN = 0x0102, + + /* Alpha testing */ + GL_ALPHA_TEST = 0x0BC0, + GL_ALPHA_TEST_REF = 0x0BC2, + GL_ALPHA_TEST_FUNC = 0x0BC1, + + /* Blending */ + GL_BLEND = 0x0BE2, + GL_BLEND_SRC = 0x0BE1, + GL_BLEND_DST = 0x0BE0, + GL_ZERO = 0, + GL_ONE = 1, + GL_SRC_COLOR = 0x0300, + GL_ONE_MINUS_SRC_COLOR = 0x0301, + GL_DST_COLOR = 0x0306, + GL_ONE_MINUS_DST_COLOR = 0x0307, + GL_SRC_ALPHA = 0x0302, + GL_ONE_MINUS_SRC_ALPHA = 0x0303, + GL_DST_ALPHA = 0x0304, + GL_ONE_MINUS_DST_ALPHA = 0x0305, + GL_SRC_ALPHA_SATURATE = 0x0308, + GL_CONSTANT_COLOR = 0x8001, + GL_ONE_MINUS_CONSTANT_COLOR = 0x8002, + GL_CONSTANT_ALPHA = 0x8003, + GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004, + + /* Render Mode */ + GL_FEEDBACK = 0x1C01, + GL_RENDER = 0x1C00, + GL_SELECT = 0x1C02, + + /* Feedback */ + GL_2D = 0x0600, + GL_3D = 0x0601, + GL_3D_COLOR = 0x0602, + GL_3D_COLOR_TEXTURE = 0x0603, + GL_4D_COLOR_TEXTURE = 0x0604, + GL_POINT_TOKEN = 0x0701, + GL_LINE_TOKEN = 0x0702, + GL_LINE_RESET_TOKEN = 0x0707, + GL_POLYGON_TOKEN = 0x0703, + GL_BITMAP_TOKEN = 0x0704, + GL_DRAW_PIXEL_TOKEN = 0x0705, + GL_COPY_PIXEL_TOKEN = 0x0706, + GL_PASS_THROUGH_TOKEN = 0x0700, + + /* Fog */ + GL_FOG = 0x0B60, + GL_FOG_MODE = 0x0B65, + GL_FOG_DENSITY = 0x0B62, + GL_FOG_COLOR = 0x0B66, + GL_FOG_INDEX = 0x0B61, + GL_FOG_START = 0x0B63, + GL_FOG_END = 0x0B64, + GL_LINEAR = 0x2601, + GL_EXP = 0x0800, + GL_EXP2 = 0x0801, + + /* Logic Ops */ + GL_LOGIC_OP = 0x0BF1, + GL_LOGIC_OP_MODE = 0x0BF0, + GL_CLEAR = 0x1500, + GL_SET = 0x150F, + GL_COPY = 0x1503, + GL_COPY_INVERTED = 0x150C, + GL_NOOP = 0x1505, + GL_INVERT = 0x150A, + GL_AND = 0x1501, + GL_NAND = 0x150E, + GL_OR = 0x1507, + GL_NOR = 0x1508, + GL_XOR = 0x1506, + GL_EQUIV = 0x1509, + GL_AND_REVERSE = 0x1502, + GL_AND_INVERTED = 0x1504, + GL_OR_REVERSE = 0x150B, + GL_OR_INVERTED = 0x150D, + + /* Stencil */ + GL_STENCIL_TEST = 0x0B90, + GL_STENCIL_WRITEMASK = 0x0B98, + GL_STENCIL_BITS = 0x0D57, + GL_STENCIL_FUNC = 0x0B92, + GL_STENCIL_VALUE_MASK = 0x0B93, + GL_STENCIL_REF = 0x0B97, + GL_STENCIL_FAIL = 0x0B94, + GL_STENCIL_PASS_DEPTH_PASS = 0x0B96, + GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95, + GL_STENCIL_CLEAR_VALUE = 0x0B91, + GL_STENCIL_INDEX = 0x1901, + GL_KEEP = 0x1E00, + GL_REPLACE = 0x1E01, + GL_INCR = 0x1E02, + GL_DECR = 0x1E03, + + /* Buffers, Pixel Drawing/Reading */ + GL_NONE = 0, + GL_LEFT = 0x0406, + GL_RIGHT = 0x0407, + /*GL_FRONT = 0x0404, */ + /*GL_BACK = 0x0405, */ + /*GL_FRONT_AND_BACK = 0x0408, */ + GL_FRONT_LEFT = 0x0400, + GL_FRONT_RIGHT = 0x0401, + GL_BACK_LEFT = 0x0402, + GL_BACK_RIGHT = 0x0403, + GL_AUX0 = 0x0409, + GL_AUX1 = 0x040A, + GL_AUX2 = 0x040B, + GL_AUX3 = 0x040C, + GL_COLOR_INDEX = 0x1900, + GL_RED = 0x1903, + GL_GREEN = 0x1904, + GL_BLUE = 0x1905, + GL_ALPHA = 0x1906, + GL_LUMINANCE = 0x1909, + GL_LUMINANCE_ALPHA = 0x190A, + GL_ALPHA_BITS = 0x0D55, + GL_RED_BITS = 0x0D52, + GL_GREEN_BITS = 0x0D53, + GL_BLUE_BITS = 0x0D54, + GL_INDEX_BITS = 0x0D51, + GL_SUBPIXEL_BITS = 0x0D50, + GL_AUX_BUFFERS = 0x0C00, + GL_READ_BUFFER = 0x0C02, + GL_DRAW_BUFFER = 0x0C01, + GL_DOUBLEBUFFER = 0x0C32, + GL_STEREO = 0x0C33, + GL_BITMAP = 0x1A00, + GL_COLOR = 0x1800, + GL_DEPTH = 0x1801, + GL_STENCIL = 0x1802, + GL_DITHER = 0x0BD0, + GL_RGB = 0x1907, + GL_RGBA = 0x1908, + + /* Implementation limits */ + GL_MAX_LIST_NESTING = 0x0B31, + GL_MAX_ATTRIB_STACK_DEPTH = 0x0D35, + GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36, + GL_MAX_NAME_STACK_DEPTH = 0x0D37, + GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38, + GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39, + GL_MAX_EVAL_ORDER = 0x0D30, + GL_MAX_LIGHTS = 0x0D31, + GL_MAX_CLIP_PLANES = 0x0D32, + GL_MAX_TEXTURE_SIZE = 0x0D33, + GL_MAX_PIXEL_MAP_TABLE = 0x0D34, + GL_MAX_VIEWPORT_DIMS = 0x0D3A, + GL_MAX_CLIENT_ATTRIB_STACK_DEPTH= 0x0D3B, + + /* Gets */ + GL_ATTRIB_STACK_DEPTH = 0x0BB0, + GL_COLOR_CLEAR_VALUE = 0x0C22, + GL_COLOR_WRITEMASK = 0x0C23, + GL_CURRENT_INDEX = 0x0B01, + GL_CURRENT_COLOR = 0x0B00, + GL_CURRENT_NORMAL = 0x0B02, + GL_CURRENT_RASTER_COLOR = 0x0B04, + GL_CURRENT_RASTER_DISTANCE = 0x0B09, + GL_CURRENT_RASTER_INDEX = 0x0B05, + GL_CURRENT_RASTER_POSITION = 0x0B07, + GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06, + GL_CURRENT_RASTER_POSITION_VALID = 0x0B08, + GL_CURRENT_TEXTURE_COORDS = 0x0B03, + GL_INDEX_CLEAR_VALUE = 0x0C20, + GL_INDEX_MODE = 0x0C30, + GL_INDEX_WRITEMASK = 0x0C21, + GL_MODELVIEW_MATRIX = 0x0BA6, + GL_MODELVIEW_STACK_DEPTH = 0x0BA3, + GL_NAME_STACK_DEPTH = 0x0D70, + GL_PROJECTION_MATRIX = 0x0BA7, + GL_PROJECTION_STACK_DEPTH = 0x0BA4, + GL_RENDER_MODE = 0x0C40, + GL_RGBA_MODE = 0x0C31, + GL_TEXTURE_MATRIX = 0x0BA8, + GL_TEXTURE_STACK_DEPTH = 0x0BA5, + GL_VIEWPORT = 0x0BA2, + + + /* Evaluators */ + GL_AUTO_NORMAL = 0x0D80, + GL_MAP1_COLOR_4 = 0x0D90, + GL_MAP1_GRID_DOMAIN = 0x0DD0, + GL_MAP1_GRID_SEGMENTS = 0x0DD1, + GL_MAP1_INDEX = 0x0D91, + GL_MAP1_NORMAL = 0x0D92, + GL_MAP1_TEXTURE_COORD_1 = 0x0D93, + GL_MAP1_TEXTURE_COORD_2 = 0x0D94, + GL_MAP1_TEXTURE_COORD_3 = 0x0D95, + GL_MAP1_TEXTURE_COORD_4 = 0x0D96, + GL_MAP1_VERTEX_3 = 0x0D97, + GL_MAP1_VERTEX_4 = 0x0D98, + GL_MAP2_COLOR_4 = 0x0DB0, + GL_MAP2_GRID_DOMAIN = 0x0DD2, + GL_MAP2_GRID_SEGMENTS = 0x0DD3, + GL_MAP2_INDEX = 0x0DB1, + GL_MAP2_NORMAL = 0x0DB2, + GL_MAP2_TEXTURE_COORD_1 = 0x0DB3, + GL_MAP2_TEXTURE_COORD_2 = 0x0DB4, + GL_MAP2_TEXTURE_COORD_3 = 0x0DB5, + GL_MAP2_TEXTURE_COORD_4 = 0x0DB6, + GL_MAP2_VERTEX_3 = 0x0DB7, + GL_MAP2_VERTEX_4 = 0x0DB8, + GL_COEFF = 0x0A00, + GL_DOMAIN = 0x0A02, + GL_ORDER = 0x0A01, + + /* Hints */ + GL_FOG_HINT = 0x0C54, + GL_LINE_SMOOTH_HINT = 0x0C52, + GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50, + GL_POINT_SMOOTH_HINT = 0x0C51, + GL_POLYGON_SMOOTH_HINT = 0x0C53, + GL_DONT_CARE = 0x1100, + GL_FASTEST = 0x1101, + GL_NICEST = 0x1102, + + /* Scissor box */ + GL_SCISSOR_TEST = 0x0C11, + GL_SCISSOR_BOX = 0x0C10, + + /* Pixel Mode / Transfer */ + GL_MAP_COLOR = 0x0D10, + GL_MAP_STENCIL = 0x0D11, + GL_INDEX_SHIFT = 0x0D12, + GL_INDEX_OFFSET = 0x0D13, + GL_RED_SCALE = 0x0D14, + GL_RED_BIAS = 0x0D15, + GL_GREEN_SCALE = 0x0D18, + GL_GREEN_BIAS = 0x0D19, + GL_BLUE_SCALE = 0x0D1A, + GL_BLUE_BIAS = 0x0D1B, + GL_ALPHA_SCALE = 0x0D1C, + GL_ALPHA_BIAS = 0x0D1D, + GL_DEPTH_SCALE = 0x0D1E, + GL_DEPTH_BIAS = 0x0D1F, + GL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1, + GL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0, + GL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2, + GL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3, + GL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4, + GL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5, + GL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6, + GL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7, + GL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8, + GL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9, + GL_PIXEL_MAP_S_TO_S = 0x0C71, + GL_PIXEL_MAP_I_TO_I = 0x0C70, + GL_PIXEL_MAP_I_TO_R = 0x0C72, + GL_PIXEL_MAP_I_TO_G = 0x0C73, + GL_PIXEL_MAP_I_TO_B = 0x0C74, + GL_PIXEL_MAP_I_TO_A = 0x0C75, + GL_PIXEL_MAP_R_TO_R = 0x0C76, + GL_PIXEL_MAP_G_TO_G = 0x0C77, + GL_PIXEL_MAP_B_TO_B = 0x0C78, + GL_PIXEL_MAP_A_TO_A = 0x0C79, + GL_PACK_ALIGNMENT = 0x0D05, + GL_PACK_LSB_FIRST = 0x0D01, + GL_PACK_ROW_LENGTH = 0x0D02, + GL_PACK_SKIP_PIXELS = 0x0D04, + GL_PACK_SKIP_ROWS = 0x0D03, + GL_PACK_SWAP_BYTES = 0x0D00, + GL_UNPACK_ALIGNMENT = 0x0CF5, + GL_UNPACK_LSB_FIRST = 0x0CF1, + GL_UNPACK_ROW_LENGTH = 0x0CF2, + GL_UNPACK_SKIP_PIXELS = 0x0CF4, + GL_UNPACK_SKIP_ROWS = 0x0CF3, + GL_UNPACK_SWAP_BYTES = 0x0CF0, + GL_ZOOM_X = 0x0D16, + GL_ZOOM_Y = 0x0D17, + + /* Texture mapping */ + GL_TEXTURE_ENV = 0x2300, + GL_TEXTURE_ENV_MODE = 0x2200, + GL_TEXTURE_1D = 0x0DE0, + GL_TEXTURE_2D = 0x0DE1, + GL_TEXTURE_WRAP_S = 0x2802, + GL_TEXTURE_WRAP_T = 0x2803, + GL_TEXTURE_MAG_FILTER = 0x2800, + GL_TEXTURE_MIN_FILTER = 0x2801, + GL_TEXTURE_ENV_COLOR = 0x2201, + GL_TEXTURE_GEN_S = 0x0C60, + GL_TEXTURE_GEN_T = 0x0C61, + GL_TEXTURE_GEN_MODE = 0x2500, + GL_TEXTURE_BORDER_COLOR = 0x1004, + GL_TEXTURE_WIDTH = 0x1000, + GL_TEXTURE_HEIGHT = 0x1001, + GL_TEXTURE_BORDER = 0x1005, + GL_TEXTURE_COMPONENTS = 0x1003, + GL_NEAREST_MIPMAP_NEAREST = 0x2700, + GL_NEAREST_MIPMAP_LINEAR = 0x2702, + GL_LINEAR_MIPMAP_NEAREST = 0x2701, + GL_LINEAR_MIPMAP_LINEAR = 0x2703, + GL_OBJECT_LINEAR = 0x2401, + GL_OBJECT_PLANE = 0x2501, + GL_EYE_LINEAR = 0x2400, + GL_EYE_PLANE = 0x2502, + GL_SPHERE_MAP = 0x2402, + GL_DECAL = 0x2101, + GL_MODULATE = 0x2100, + GL_NEAREST = 0x2600, + GL_REPEAT = 0x2901, + GL_CLAMP = 0x2900, + GL_S = 0x2000, + GL_T = 0x2001, + GL_R = 0x2002, + GL_Q = 0x2003, + GL_TEXTURE_GEN_R = 0x0C62, + GL_TEXTURE_GEN_Q = 0x0C63, + + GL_PROXY_TEXTURE_1D = 0x8063, + GL_PROXY_TEXTURE_2D = 0x8064, + GL_TEXTURE_PRIORITY = 0x8066, + GL_TEXTURE_RESIDENT = 0x8067, + GL_TEXTURE_1D_BINDING = 0x8068, + GL_TEXTURE_2D_BINDING = 0x8069, + + /* Internal texture formats */ + GL_ALPHA4 = 0x803B, + GL_ALPHA8 = 0x803C, + GL_ALPHA12 = 0x803D, + GL_ALPHA16 = 0x803E, + GL_LUMINANCE4 = 0x803F, + GL_LUMINANCE8 = 0x8040, + GL_LUMINANCE12 = 0x8041, + GL_LUMINANCE16 = 0x8042, + GL_LUMINANCE4_ALPHA4 = 0x8043, + GL_LUMINANCE6_ALPHA2 = 0x8044, + GL_LUMINANCE8_ALPHA8 = 0x8045, + GL_LUMINANCE12_ALPHA4 = 0x8046, + GL_LUMINANCE12_ALPHA12 = 0x8047, + GL_LUMINANCE16_ALPHA16 = 0x8048, + GL_INTENSITY = 0x8049, + GL_INTENSITY4 = 0x804A, + GL_INTENSITY8 = 0x804B, + GL_INTENSITY12 = 0x804C, + GL_INTENSITY16 = 0x804D, + GL_R3_G3_B2 = 0x2A10, + GL_RGB4 = 0x804F, + GL_RGB5 = 0x8050, + GL_RGB8 = 0x8051, + GL_RGB10 = 0x8052, + GL_RGB12 = 0x8053, + GL_RGB16 = 0x8054, + GL_RGBA2 = 0x8055, + GL_RGBA4 = 0x8056, + GL_RGB5_A1 = 0x8057, + GL_RGBA8 = 0x8058, + GL_RGB10_A2 = 0x8059, + GL_RGBA12 = 0x805A, + GL_RGBA16 = 0x805B, + + /* Utility */ + GL_VENDOR = 0x1F00, + GL_RENDERER = 0x1F01, + GL_VERSION = 0x1F02, + GL_EXTENSIONS = 0x1F03, + + /* Errors */ + GL_INVALID_VALUE = 0x0501, + GL_INVALID_ENUM = 0x0500, + GL_INVALID_OPERATION = 0x0502, + GL_STACK_OVERFLOW = 0x0503, + GL_STACK_UNDERFLOW = 0x0504, + GL_OUT_OF_MEMORY = 0x0505, + + /* + * 1.0 Extensions + */ + /* GL_EXT_blend_minmax and GL_EXT_blend_color */ + GL_CONSTANT_COLOR_EXT = 0x8001, + GL_ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002, + GL_CONSTANT_ALPHA_EXT = 0x8003, + GL_ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004, + GL_BLEND_EQUATION_EXT = 0x8009, + GL_MIN_EXT = 0x8007, + GL_MAX_EXT = 0x8008, + GL_FUNC_ADD_EXT = 0x8006, + GL_FUNC_SUBTRACT_EXT = 0x800A, + GL_FUNC_REVERSE_SUBTRACT_EXT = 0x800B, + GL_BLEND_COLOR_EXT = 0x8005, + + /* GL_EXT_polygon_offset */ + GL_POLYGON_OFFSET_EXT = 0x8037, + GL_POLYGON_OFFSET_FACTOR_EXT = 0x8038, + GL_POLYGON_OFFSET_BIAS_EXT = 0x8039, + + /* GL_EXT_vertex_array */ + GL_VERTEX_ARRAY_EXT = 0x8074, + GL_NORMAL_ARRAY_EXT = 0x8075, + GL_COLOR_ARRAY_EXT = 0x8076, + GL_INDEX_ARRAY_EXT = 0x8077, + GL_TEXTURE_COORD_ARRAY_EXT = 0x8078, + GL_EDGE_FLAG_ARRAY_EXT = 0x8079, + GL_VERTEX_ARRAY_SIZE_EXT = 0x807A, + GL_VERTEX_ARRAY_TYPE_EXT = 0x807B, + GL_VERTEX_ARRAY_STRIDE_EXT = 0x807C, + GL_VERTEX_ARRAY_COUNT_EXT = 0x807D, + GL_NORMAL_ARRAY_TYPE_EXT = 0x807E, + GL_NORMAL_ARRAY_STRIDE_EXT = 0x807F, + GL_NORMAL_ARRAY_COUNT_EXT = 0x8080, + GL_COLOR_ARRAY_SIZE_EXT = 0x8081, + GL_COLOR_ARRAY_TYPE_EXT = 0x8082, + GL_COLOR_ARRAY_STRIDE_EXT = 0x8083, + GL_COLOR_ARRAY_COUNT_EXT = 0x8084, + GL_INDEX_ARRAY_TYPE_EXT = 0x8085, + GL_INDEX_ARRAY_STRIDE_EXT = 0x8086, + GL_INDEX_ARRAY_COUNT_EXT = 0x8087, + GL_TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088, + GL_TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089, + GL_TEXTURE_COORD_ARRAY_STRIDE_EXT= 0x808A, + GL_TEXTURE_COORD_ARRAY_COUNT_EXT= 0x808B, + GL_EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C, + GL_EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D, + GL_VERTEX_ARRAY_POINTER_EXT = 0x808E, + GL_NORMAL_ARRAY_POINTER_EXT = 0x808F, + GL_COLOR_ARRAY_POINTER_EXT = 0x8090, + GL_INDEX_ARRAY_POINTER_EXT = 0x8091, + GL_TEXTURE_COORD_ARRAY_POINTER_EXT= 0x8092, + GL_EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093 + +}; + +enum { + GL_CURRENT_BIT = 0x00000001, + GL_POINT_BIT = 0x00000002, + GL_LINE_BIT = 0x00000004, + GL_POLYGON_BIT = 0x00000008, + GL_POLYGON_STIPPLE_BIT = 0x00000010, + GL_PIXEL_MODE_BIT = 0x00000020, + GL_LIGHTING_BIT = 0x00000040, + GL_FOG_BIT = 0x00000080, + GL_DEPTH_BUFFER_BIT = 0x00000100, + GL_ACCUM_BUFFER_BIT = 0x00000200, + GL_STENCIL_BUFFER_BIT = 0x00000400, + GL_VIEWPORT_BIT = 0x00000800, + GL_TRANSFORM_BIT = 0x00001000, + GL_ENABLE_BIT = 0x00002000, + GL_COLOR_BUFFER_BIT = 0x00004000, + GL_HINT_BIT = 0x00008000, + GL_EVAL_BIT = 0x00010000, + GL_LIST_BIT = 0x00020000, + GL_TEXTURE_BIT = 0x00040000, + GL_SCISSOR_BIT = 0x00080000, + GL_ALL_ATTRIB_BITS = 0x000fffff +}; + +/* some types */ + +typedef int GLenum; +typedef void GLvoid; +typedef unsigned char GLboolean; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef float GLfloat; /* single precision float */ +typedef double GLdouble; /* double precision float */ +typedef int GLsizei; + +/* functions */ + +void glEnable(int code); +void glDisable(int code); + +void glShadeModel(int mode); +void glCullFace(int mode); +void glPolygonMode(int face,int mode); + +void glBegin(int type); +void glEnd(void); + +#define PROTO_GL1(name) \ +void gl ## name ## 1f(float); \ +void gl ## name ## 1d(double); \ +void gl ## name ## 1fv(float *); \ +void gl ## name ## 1dv(double *); + +#define PROTO_GL2(name) \ +void gl ## name ## 2f(float ,float); \ +void gl ## name ## 2d(double ,double); \ +void gl ## name ## 2fv(float *); \ +void gl ## name ## 2dv(double *); + +#define PROTO_GL3(name) \ +void gl ## name ## 3f(float ,float ,float); \ +void gl ## name ## 3d(double ,double ,double); \ +void gl ## name ## 3fv(float *); \ +void gl ## name ## 3dv(double *); + +#define PROTO_GL4(name) \ +void gl ## name ## 4f(float ,float ,float, float ); \ +void gl ## name ## 4d(double ,double ,double, double ); \ +void gl ## name ## 4fv(float *); \ +void gl ## name ## 4dv(double *); + +PROTO_GL2(Vertex) +PROTO_GL3(Vertex) +PROTO_GL4(Vertex) + +PROTO_GL3(Color) +PROTO_GL4(Color) + +PROTO_GL3(Normal) + +PROTO_GL1(TexCoord) +PROTO_GL2(TexCoord) +PROTO_GL3(TexCoord) +PROTO_GL4(TexCoord) + +void glEdgeFlag(int flag); + +/* matrix */ +void glMatrixMode(int mode); +void glLoadMatrixf(const float *m); +void glLoadIdentity(void); +void glMultMatrixf(const float *m); +void glPushMatrix(void); +void glPopMatrix(void); +void glRotatef(float angle,float x,float y,float z); +void glTranslatef(float x,float y,float z); +void glScalef(float x,float y,float z); + +void glViewport(int x,int y,int width,int height); +void glFrustum(double left,double right,double bottom,double top, + double near,double far); + +/* lists */ +unsigned int glGenLists(int range); +int glIsList(unsigned int list); +void glNewList(unsigned int list,int mode); +void glEndList(void); +void glCallList(unsigned int list); + +/* clear */ +void glClear(int mask); +void glClearColor(float r,float g,float b,float a); +void glClearDepth(double depth); + +/* selection */ +int glRenderMode(int mode); +void glSelectBuffer(int size,unsigned int *buf); + +void glInitNames(void); +void glPushName(unsigned int name); +void glPopName(void); +void glLoadName(unsigned int name); + +/* textures */ +void glGenTextures(int n, unsigned int *textures); +void glDeleteTextures(int n, const unsigned int *textures); +void glBindTexture(int target,int texture); +void glTexImage2D( int target, int level, int components, + int width, int height, int border, + int format, int type, void *pixels); +void glTexEnvi(int target,int pname,int param); +void glTexParameteri(int target,int pname,int param); +void glPixelStorei(int pname,int param); + +/* lighting */ + +void glMaterialfv(int mode,int type,float *v); +void glMaterialf(int mode,int type,float v); +void glColorMaterial(int mode,int type); + +void glLightfv(int light,int type,float *v); +void glLightf(int light,int type,float v); +void glLightModeli(int pname,int param); +void glLightModelfv(int pname,float *param); + +/* misc */ + +void glFlush(void); +void glHint(int target,int mode); +void glGetIntegerv(int pname,int *params); +void glGetFloatv(int pname, float *v); +void glFrontFace(int mode); + +/* opengl 1.2 arrays */ +void glEnableClientState(GLenum array); +void glDisableClientState(GLenum array); +void glArrayElement(GLint i); +void glVertexPointer(GLint size, GLenum type, GLsizei stride, + const GLvoid *pointer); +void glColorPointer(GLint size, GLenum type, GLsizei stride, + const GLvoid *pointer); +void glNormalPointer(GLenum type, GLsizei stride, + const GLvoid *pointer); +void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, + const GLvoid *pointer); + +/* opengl 1.2 polygon offset */ +void glPolygonOffset(GLfloat factor, GLfloat units); + +/* not implemented, just added to compile */ + /* +inline void glPointSize(float) {} +inline void glLineWidth(float) {} +inline void glDeleteLists(int, int) {} +inline void glDepthFunc(int) {} +inline void glBlendFunc(int, int) {} +inline void glTexEnvf(int, int, int) {} +inline void glOrtho(float,float,float,float,float,float){} +inline void glVertex2i(int,int) {} +inline void glDepthMask(int) {} +inline void glFogi(int, int) {} +inline void glFogfv(int, const float*) {} +inline void glFogf(int, float) {} +inline void glRasterPos2f(float, float) {} +inline void glPolygonStipple(void*) {} +inline void glTexParameterf(int, int, int) {}; + */ +/* non compatible functions */ + +void glDebug(int mode); + +void glInit(void *zbuffer); +void glClose(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/tinygl-0.4-ugfx/include/GL/glx.h b/3rdparty/tinygl-0.4-ugfx/include/GL/glx.h new file mode 100644 index 00000000..67fd68a3 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/include/GL/glx.h @@ -0,0 +1,144 @@ +#ifndef GLX_H +#define GLX_H + +#include +#include +#include + + +/* the following comes from Mesa */ + +#ifdef __cplusplus +extern "C" { +#endif + + +#define GLX_VERSION_1_1 1 + + +/* + * Tokens for glXChooseVisual and glXGetConfig: + */ +enum _GLX_CONFIGS { + GLX_USE_GL = 1, + GLX_BUFFER_SIZE = 2, + GLX_LEVEL = 3, + GLX_RGBA = 4, + GLX_DOUBLEBUFFER = 5, + GLX_STEREO = 6, + GLX_AUX_BUFFERS = 7, + GLX_RED_SIZE = 8, + GLX_GREEN_SIZE = 9, + GLX_BLUE_SIZE = 10, + GLX_ALPHA_SIZE = 11, + GLX_DEPTH_SIZE = 12, + GLX_STENCIL_SIZE = 13, + GLX_ACCUM_RED_SIZE = 14, + GLX_ACCUM_GREEN_SIZE = 15, + GLX_ACCUM_BLUE_SIZE = 16, + GLX_ACCUM_ALPHA_SIZE = 17, + + /* GLX_EXT_visual_info extension */ + GLX_X_VISUAL_TYPE_EXT = 0x22, + GLX_TRANSPARENT_TYPE_EXT = 0x23, + GLX_TRANSPARENT_INDEX_VALUE_EXT = 0x24, + GLX_TRANSPARENT_RED_VALUE_EXT = 0x25, + GLX_TRANSPARENT_GREEN_VALUE_EXT = 0x26, + GLX_TRANSPARENT_BLUE_VALUE_EXT = 0x27, + GLX_TRANSPARENT_ALPHA_VALUE_EXT = 0x28 +}; + + +/* + * Error codes returned by glXGetConfig: + */ +#define GLX_BAD_SCREEN 1 +#define GLX_BAD_ATTRIBUTE 2 +#define GLX_NO_EXTENSION 3 +#define GLX_BAD_VISUAL 4 +#define GLX_BAD_CONTEXT 5 +#define GLX_BAD_VALUE 6 +#define GLX_BAD_ENUM 7 + + +/* + * GLX 1.1 and later: + */ +#define GLX_VENDOR 1 +#define GLX_VERSION 2 +#define GLX_EXTENSIONS 3 + + +/* + * GLX_visual_info extension + */ +#define GLX_TRUE_COLOR_EXT 0x8002 +#define GLX_DIRECT_COLOR_EXT 0x8003 +#define GLX_PSEUDO_COLOR_EXT 0x8004 +#define GLX_STATIC_COLOR_EXT 0x8005 +#define GLX_GRAY_SCALE_EXT 0x8006 +#define GLX_STATIC_GRAY_EXT 0x8007 +#define GLX_NONE_EXT 0x8000 +#define GLX_TRANSPARENT_RGB_EXT 0x8008 +#define GLX_TRANSPARENT_INDEX_EXT 0x8009 + + +typedef void *GLXContext; +typedef Pixmap GLXPixmap; +typedef Drawable GLXDrawable; +typedef XID GLXContextID; + + +extern XVisualInfo* glXChooseVisual( Display *dpy, int screen, + int *attribList ); + +extern GLXContext glXCreateContext( Display *dpy, XVisualInfo *vis, + GLXContext shareList, Bool direct ); + +extern void glXDestroyContext( Display *dpy, GLXContext ctx ); + +extern Bool glXMakeCurrent( Display *dpy, GLXDrawable drawable, + GLXContext ctx); + +extern void glXCopyContext( Display *dpy, GLXContext src, GLXContext dst, + GLuint mask ); + +extern void glXSwapBuffers( Display *dpy, GLXDrawable drawable ); + +extern GLXPixmap glXCreateGLXPixmap( Display *dpy, XVisualInfo *visual, + Pixmap pixmap ); + +extern void glXDestroyGLXPixmap( Display *dpy, GLXPixmap pixmap ); + +extern Bool glXQueryExtension( Display *dpy, int *errorb, int *event ); + +extern Bool glXQueryVersion( Display *dpy, int *maj, int *min ); + +extern Bool glXIsDirect( Display *dpy, GLXContext ctx ); + +extern int glXGetConfig( Display *dpy, XVisualInfo *visual, + int attrib, int *value ); + +extern GLXContext glXGetCurrentContext( void ); + +extern GLXDrawable glXGetCurrentDrawable( void ); + +extern void glXWaitGL( void ); + +extern void glXWaitX( void ); + +extern void glXUseXFont( Font font, int first, int count, int list ); + + +/* GLX 1.1 and later */ +extern const char *glXQueryExtensionsString( Display *dpy, int screen ); + +extern const char *glXQueryServerString( Display *dpy, int screen, int name ); + +extern const char *glXGetClientString( Display *dpy, int name ); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/tinygl-0.4-ugfx/include/GL/nglx.h b/3rdparty/tinygl-0.4-ugfx/include/GL/nglx.h new file mode 100644 index 00000000..d2f6114f --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/include/GL/nglx.h @@ -0,0 +1,27 @@ +#ifndef NGLX_H +#define NGLX_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *NGLXContext; +typedef GR_DRAW_ID NGLXDrawable; + +extern NGLXContext nglXCreateContext( NGLXContext shareList, int flags ); + +extern void nglXDestroyContext( NGLXContext ctx ); + +extern int nglXMakeCurrent( NGLXDrawable drawable, + NGLXContext ctx); + +extern void nglXSwapBuffers( NGLXDrawable drawable ); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/3rdparty/tinygl-0.4-ugfx/include/GL/oscontext.h b/3rdparty/tinygl-0.4-ugfx/include/GL/oscontext.h new file mode 100644 index 00000000..a044f225 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/include/GL/oscontext.h @@ -0,0 +1,37 @@ +#ifndef _tgl_osbuffer_h_ +#define _tgl_osbuffer_h_ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + void **zbs; + void **framebuffers; + int numbuffers; + int xsize, ysize; +} ostgl_context; + +ostgl_context * +ostgl_create_context(const int xsize, + const int ysize, + const int depth, + void **framebuffers, + const int numbuffers); +void +ostgl_delete_context(ostgl_context *context); + +void +ostgl_make_current(ostgl_context *context, const int index); + +void +ostgl_resize(ostgl_context * context, + const int xsize, + const int ysize, + void **framebuffers); + +#ifdef __cplusplus +} +#endif + +#endif /* _tgl_osbuffer_h_ */ diff --git a/3rdparty/tinygl-0.4-ugfx/include/GLView.h b/3rdparty/tinygl-0.4-ugfx/include/GLView.h new file mode 100644 index 00000000..6791e5aa --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/include/GLView.h @@ -0,0 +1,72 @@ +#ifndef _glview_h_ +#define _glview_h_ + +#define BGL_RGB 0 +#define BGL_INDEX 1 +#define BGL_SINGLE 0 +#define BGL_DOUBLE 2 +#define BGL_DIRECT 0 +#define BGL_INDIRECT 4 +#define BGL_ACCUM 8 +#define BGL_ALPHA 16 +#define BGL_DEPTH 32 +#define BGL_OVERLAY 64 +#define BGL_UNDERLAY 128 +#define BGL_STENCIL 512 + +#include +#include +#include +#include +#include +#include + +class BGLView : public BView { +public: + BGLView(BRect rect, char *name, + ulong resizingMode, ulong mode, + ulong options); + virtual ~BGLView(); + + void LockGL(); + void UnlockGL(); + void SwapBuffers(); +// BView *EmbeddedView(); +// status_t CopyPixelsOut(BPoint source, BBitmap *dest); +// status_t CopyPixelsIn(BBitmap *source, BPoint dest); + + virtual void ErrorCallback(GLenum errorCode); + virtual void Draw(BRect updateRect); + virtual void AttachedToWindow(); + virtual void AllAttached(); + virtual void DetachedFromWindow(); + virtual void AllDetached(); + virtual void FrameResized(float width, float height); +// virtual status_t Perform(perform_code d, void *arg); + + // + // Methods below are pass-throughs to BView for the moment. + // + + virtual status_t Archive(BMessage *data, bool deep = true) const; + virtual void MessageReceived(BMessage *msg); + virtual void SetResizingMode(uint32 mode); + + virtual void Show(); + virtual void Hide(); + + virtual BHandler *ResolveSpecifier(BMessage *msg, int32 index, + BMessage *specifier, int32 form, + const char *property); + virtual status_t GetSupportedSuites(BMessage *data); + //void DirectConnected( direct_buffer_info *info ); + //void EnableDirectMode( bool enabled ); + +private: + ostgl_context *context; + BBitmap *bitmaps[2]; + int currBitmap; + static BLocker locker; +}; + +#endif // _glview_h_ diff --git a/3rdparty/tinygl-0.4-ugfx/src/Makefile b/3rdparty/tinygl-0.4-ugfx/src/Makefile new file mode 100644 index 00000000..829d3bfb --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/Makefile @@ -0,0 +1,43 @@ +include ../config.mk + +OBJS= api.o list.o vertex.o init.o matrix.o texture.o \ + misc.o clear.o light.o clip.o select.o get.o error.o \ + zbuffer.o zline.o zdither.o ztriangle.o \ + zmath.o image_util.o oscontext.o msghandling.o \ + arrays.o specbuf.o memory.o +ifdef TINYGL_USE_GLX +OBJS += glx.o +endif +ifdef TINYGL_USE_NANOX +OBJS += nglx.o +endif + +INCLUDES = -I../include +LIB = libTinyGL.a + +all: $(LIB) + +$(LIB): $(OBJS) + rm -f $(LIB) + ar rcs $(LIB) $(OBJS) + cp $(LIB) ../lib + +clean: + rm -f *~ *.o *.a + +.c.o: + $(CC) $(CFLAGS) $(INCLUDES) -c $*.c + +clip.o: zgl.h zfeatures.h +vertex.o: zgl.h zfeatures.h +light.o: zgl.h zfeatures.h +matrix.o: zgl.h zfeatures.h +list.o: zgl.h opinfo.h zfeatures.h +arrays.c: zgl.h zfeatures.h +specbuf.o: zgl.h zfeatures.h +glx.o: zgl.h zfeatures.h +nglx.o: zgl.h zfeatures.h +zline.o: zgl.h zfeatures.h zline.h + +ztriangle.o: ztriangle.c ztriangle.h zgl.h zfeatures.h + $(CC) $(CFLAGS) -Wno-uninitialized $(INCLUDES) -c $*.c diff --git a/3rdparty/tinygl-0.4-ugfx/src/api.c b/3rdparty/tinygl-0.4-ugfx/src/api.c new file mode 100644 index 00000000..11764a1e --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/api.c @@ -0,0 +1,667 @@ +#include "zgl.h" +#include +/* glVertex */ + +void glVertex4f(float x,float y,float z,float w) +{ + GLParam p[5]; + + p[0].op=OP_Vertex; + p[1].f=x; + p[2].f=y; + p[3].f=z; + p[4].f=w; + + gl_add_op(p); +} + +void glVertex2f(float x,float y) +{ + glVertex4f(x,y,0,1); +} + +void glVertex3f(float x,float y,float z) +{ + glVertex4f(x,y,z,1); +} + +void glVertex3fv(float *v) +{ + glVertex4f(v[0],v[1],v[2],1); +} + +/* glNormal */ + +void glNormal3f(float x,float y,float z) +{ + GLParam p[4]; + + p[0].op=OP_Normal; + p[1].f=x; + p[2].f=y; + p[3].f=z; + + gl_add_op(p); +} + +void glNormal3fv(float *v) +{ + glNormal3f(v[0],v[1],v[2]); +} + +/* glColor */ + +void glColor4f(float r,float g,float b,float a) +{ + GLParam p[8]; + + p[0].op=OP_Color; + p[1].f=r; + p[2].f=g; + p[3].f=b; + p[4].f=a; + /* direct convertion to integer to go faster if no shading */ + p[5].ui = (unsigned int) (r * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) + + ZB_POINT_RED_MIN); + p[6].ui = (unsigned int) (g * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) + + ZB_POINT_GREEN_MIN); + p[7].ui = (unsigned int) (b * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) + + ZB_POINT_BLUE_MIN); + gl_add_op(p); +} + +void glColor4fv(float *v) +{ + GLParam p[8]; + + p[0].op=OP_Color; + p[1].f=v[0]; + p[2].f=v[1]; + p[3].f=v[2]; + p[4].f=v[3]; + /* direct convertion to integer to go faster if no shading */ + p[5].ui = (unsigned int) (v[0] * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) + + ZB_POINT_RED_MIN); + p[6].ui = (unsigned int) (v[1] * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) + + ZB_POINT_GREEN_MIN); + p[7].ui = (unsigned int) (v[2] * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) + + ZB_POINT_BLUE_MIN); + gl_add_op(p); +} + +void glColor3f(float x,float y,float z) +{ + glColor4f(x,y,z,1); +} + +void glColor3fv(float *v) +{ + glColor4f(v[0],v[1],v[2],1); +} + + +/* TexCoord */ + +void glTexCoord4f(float s,float t,float r,float q) +{ + GLParam p[5]; + + p[0].op=OP_TexCoord; + p[1].f=s; + p[2].f=t; + p[3].f=r; + p[4].f=q; + + gl_add_op(p); +} + +void glTexCoord2f(float s,float t) +{ + glTexCoord4f(s,t,0,1); +} + +void glTexCoord2fv(float *v) +{ + glTexCoord4f(v[0],v[1],0,1); +} + +void glEdgeFlag(int flag) +{ + GLParam p[2]; + + p[0].op=OP_EdgeFlag; + p[1].i=flag; + + gl_add_op(p); +} + +/* misc */ + +void glShadeModel(int mode) +{ + GLParam p[2]; + + gl_assert(mode == GL_FLAT || mode == GL_SMOOTH); + + p[0].op=OP_ShadeModel; + p[1].i=mode; + + gl_add_op(p); +} + +void glCullFace(int mode) +{ + GLParam p[2]; + + gl_assert(mode == GL_BACK || + mode == GL_FRONT || + mode == GL_FRONT_AND_BACK); + + p[0].op=OP_CullFace; + p[1].i=mode; + + gl_add_op(p); +} + +void glFrontFace(int mode) +{ + GLParam p[2]; + + gl_assert(mode == GL_CCW || mode == GL_CW); + + mode = (mode != GL_CCW); + + p[0].op=OP_FrontFace; + p[1].i=mode; + + gl_add_op(p); +} + +void glPolygonMode(int face,int mode) +{ + GLParam p[3]; + + gl_assert(face == GL_BACK || + face == GL_FRONT || + face == GL_FRONT_AND_BACK); + gl_assert(mode == GL_POINT || mode == GL_LINE || mode==GL_FILL); + + p[0].op=OP_PolygonMode; + p[1].i=face; + p[2].i=mode; + + gl_add_op(p); +} + + +/* glEnable / glDisable */ + +void glEnable(int cap) +{ + GLParam p[3]; + + p[0].op=OP_EnableDisable; + p[1].i=cap; + p[2].i=1; + + gl_add_op(p); +} + +void glDisable(int cap) +{ + GLParam p[3]; + + p[0].op=OP_EnableDisable; + p[1].i=cap; + p[2].i=0; + + gl_add_op(p); +} + +/* glBegin / glEnd */ + +void glBegin(int mode) +{ + GLParam p[2]; + + p[0].op=OP_Begin; + p[1].i=mode; + + gl_add_op(p); +} + +void glEnd(void) +{ + GLParam p[1]; + + p[0].op=OP_End; + + gl_add_op(p); +} + +/* matrix */ + +void glMatrixMode(int mode) +{ + GLParam p[2]; + + p[0].op=OP_MatrixMode; + p[1].i=mode; + + gl_add_op(p); +} + +void glLoadMatrixf(const float *m) +{ + GLParam p[17]; + int i; + + p[0].op=OP_LoadMatrix; + for(i=0;i<16;i++) p[i+1].f=m[i]; + + gl_add_op(p); +} + +void glLoadIdentity(void) +{ + GLParam p[1]; + + p[0].op=OP_LoadIdentity; + + gl_add_op(p); +} + +void glMultMatrixf(const float *m) +{ + GLParam p[17]; + int i; + + p[0].op=OP_MultMatrix; + for(i=0;i<16;i++) p[i+1].f=m[i]; + + gl_add_op(p); +} + +void glPushMatrix(void) +{ + GLParam p[1]; + + p[0].op=OP_PushMatrix; + + gl_add_op(p); +} + +void glPopMatrix(void) +{ + GLParam p[1]; + + p[0].op=OP_PopMatrix; + + gl_add_op(p); +} + +void glRotatef(float angle,float x,float y,float z) +{ + GLParam p[5]; + + p[0].op=OP_Rotate; + p[1].f=angle; + p[2].f=x; + p[3].f=y; + p[4].f=z; + + gl_add_op(p); +} + +void glTranslatef(float x,float y,float z) +{ + GLParam p[4]; + + p[0].op=OP_Translate; + p[1].f=x; + p[2].f=y; + p[3].f=z; + + gl_add_op(p); +} + +void glScalef(float x,float y,float z) +{ + GLParam p[4]; + + p[0].op=OP_Scale; + p[1].f=x; + p[2].f=y; + p[3].f=z; + + gl_add_op(p); +} + + +void glViewport(int x,int y,int width,int height) +{ + GLParam p[5]; + + p[0].op=OP_Viewport; + p[1].i=x; + p[2].i=y; + p[3].i=width; + p[4].i=height; + + gl_add_op(p); +} + +void glFrustum(double left,double right,double bottom,double top, + double xnear,double farv) +{ + GLParam p[7]; + + p[0].op=OP_Frustum; + p[1].f=left; + p[2].f=right; + p[3].f=bottom; + p[4].f=top; + p[5].f=xnear; + p[6].f=farv; + + gl_add_op(p); +} + +/* lightening */ + +void glMaterialfv(int mode,int type,float *v) +{ + GLParam p[7]; + int i,n; + + gl_assert(mode == GL_FRONT || mode == GL_BACK || mode==GL_FRONT_AND_BACK); + + p[0].op=OP_Material; + p[1].i=mode; + p[2].i=type; + n=4; + if (type == GL_SHININESS) n=1; + for(i=0;i<4;i++) p[3+i].f=v[i]; + for(i=n;i<4;i++) p[3+i].f=0; + + gl_add_op(p); +} + +void glMaterialf(int mode,int type,float v) +{ + GLParam p[7]; + int i; + + p[0].op=OP_Material; + p[1].i=mode; + p[2].i=type; + p[3].f=v; + for(i=0;i<3;i++) p[4+i].f=0; + + gl_add_op(p); +} + +void glColorMaterial(int mode,int type) +{ + GLParam p[3]; + + p[0].op=OP_ColorMaterial; + p[1].i=mode; + p[2].i=type; + + gl_add_op(p); +} + +void glLightfv(int light,int type,float *v) +{ + GLParam p[7]; + int i; + + p[0].op=OP_Light; + p[1].i=light; + p[2].i=type; + /* TODO: 3 composants ? */ + for(i=0;i<4;i++) p[3+i].f=v[i]; + + gl_add_op(p); +} + + +void glLightf(int light,int type,float v) +{ + GLParam p[7]; + int i; + + p[0].op=OP_Light; + p[1].i=light; + p[2].i=type; + p[3].f=v; + for(i=0;i<3;i++) p[4+i].f=0; + + gl_add_op(p); +} + +void glLightModeli(int pname,int param) +{ + GLParam p[6]; + int i; + + p[0].op=OP_LightModel; + p[1].i=pname; + p[2].f=(float)param; + for(i=0;i<4;i++) p[3+i].f=0; + + gl_add_op(p); +} + +void glLightModelfv(int pname,float *param) +{ + GLParam p[6]; + int i; + + p[0].op=OP_LightModel; + p[1].i=pname; + for(i=0;i<4;i++) p[2+i].f=param[i]; + + gl_add_op(p); +} + +/* clear */ + +void glClear(int mask) +{ + GLParam p[2]; + + p[0].op=OP_Clear; + p[1].i=mask; + + gl_add_op(p); +} + +void glClearColor(float r,float g,float b,float a) +{ + GLParam p[5]; + + p[0].op=OP_ClearColor; + p[1].f=r; + p[2].f=g; + p[3].f=b; + p[4].f=a; + + gl_add_op(p); +} + +void glClearDepth(double depth) +{ + GLParam p[2]; + + p[0].op=OP_ClearDepth; + p[1].f=depth; + + gl_add_op(p); +} + + +/* textures */ + +void glTexImage2D( int target, int level, int components, + int width, int height, int border, + int format, int type, void *pixels) +{ + GLParam p[10]; + + p[0].op=OP_TexImage2D; + p[1].i=target; + p[2].i=level; + p[3].i=components; + p[4].i=width; + p[5].i=height; + p[6].i=border; + p[7].i=format; + p[8].i=type; + p[9].p=pixels; + + gl_add_op(p); +} + + +void glBindTexture(int target,int texture) +{ + GLParam p[3]; + + p[0].op=OP_BindTexture; + p[1].i=target; + p[2].i=texture; + + gl_add_op(p); +} + +void glTexEnvi(int target,int pname,int param) +{ + GLParam p[8]; + + p[0].op=OP_TexEnv; + p[1].i=target; + p[2].i=pname; + p[3].i=param; + p[4].f=0; + p[5].f=0; + p[6].f=0; + p[7].f=0; + + gl_add_op(p); +} + +void glTexParameteri(int target,int pname,int param) +{ + GLParam p[8]; + + p[0].op=OP_TexParameter; + p[1].i=target; + p[2].i=pname; + p[3].i=param; + p[4].f=0; + p[5].f=0; + p[6].f=0; + p[7].f=0; + + gl_add_op(p); +} + +void glPixelStorei(int pname,int param) +{ + GLParam p[3]; + + p[0].op=OP_PixelStore; + p[1].i=pname; + p[2].i=param; + + gl_add_op(p); +} + +/* selection */ + +void glInitNames(void) +{ + GLParam p[1]; + + p[0].op=OP_InitNames; + + gl_add_op(p); +} + +void glPushName(unsigned int name) +{ + GLParam p[2]; + + p[0].op=OP_PushName; + p[1].i=name; + + gl_add_op(p); +} + +void glPopName(void) +{ + GLParam p[1]; + + p[0].op=OP_PopName; + + gl_add_op(p); +} + +void glLoadName(unsigned int name) +{ + GLParam p[2]; + + p[0].op=OP_LoadName; + p[1].i=name; + + gl_add_op(p); +} + +void +glPolygonOffset(GLfloat factor, GLfloat units) +{ + GLParam p[3]; + p[0].op = OP_PolygonOffset; + p[1].f = factor; + p[2].f = units; + gl_add_op(p); +} + +/* Special Functions */ + +void glCallList(unsigned int list) +{ + GLParam p[2]; + + p[0].op=OP_CallList; + p[1].i=list; + + gl_add_op(p); +} + +void glFlush(void) +{ + /* nothing to do */ +} + +void glHint(int target,int mode) +{ + GLParam p[3]; + + p[0].op=OP_Hint; + p[1].i=target; + p[2].i=mode; + + gl_add_op(p); +} + +/* Non standard functions */ + +void glDebug(int mode) +{ + GLContext *c=gl_get_context(); + c->print_flag=mode; +} + diff --git a/3rdparty/tinygl-0.4-ugfx/src/arrays.c b/3rdparty/tinygl-0.4-ugfx/src/arrays.c new file mode 100644 index 00000000..85b21bed --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/arrays.c @@ -0,0 +1,207 @@ +#include "zgl.h" +#include + +#define VERTEX_ARRAY 0x0001 +#define COLOR_ARRAY 0x0002 +#define NORMAL_ARRAY 0x0004 +#define TEXCOORD_ARRAY 0x0008 + +void +glopArrayElement(GLContext *c, GLParam *param) +{ + int i; + int states = c->client_states; + int idx = param[1].i; + + if (states & COLOR_ARRAY) { + GLParam p[5]; + int size = c->color_array_size; + i = idx * (size + c->color_array_stride); + p[1].f = c->color_array[i]; + p[2].f = c->color_array[i+1]; + p[3].f = c->color_array[i+2]; + p[4].f = size > 3 ? c->color_array[i+3] : 1.0f; + glopColor(c, p); + } + if (states & NORMAL_ARRAY) { + i = idx * (3 + c->normal_array_stride); + c->current_normal.X = c->normal_array[i]; + c->current_normal.Y = c->normal_array[i+1]; + c->current_normal.Z = c->normal_array[i+2]; + c->current_normal.Z = 0.0f; + } + if (states & TEXCOORD_ARRAY) { + int size = c->texcoord_array_size; + i = idx * (size + c->texcoord_array_stride); + c->current_tex_coord.X = c->texcoord_array[i]; + c->current_tex_coord.Y = c->texcoord_array[i+1]; + c->current_tex_coord.Z = size > 2 ? c->texcoord_array[i+2] : 0.0f; + c->current_tex_coord.W = size > 3 ? c->texcoord_array[i+3] : 1.0f; + } + if (states & VERTEX_ARRAY) { + GLParam p[5]; + int size = c->vertex_array_size; + i = idx * (size + c->vertex_array_stride); + p[1].f = c->vertex_array[i]; + p[2].f = c->vertex_array[i+1]; + p[3].f = size > 2 ? c->vertex_array[i+2] : 0.0f; + p[4].f = size > 3 ? c->vertex_array[i+3] : 1.0f; + glopVertex(c, p); + } +} + +void +glArrayElement(GLint i) +{ + GLParam p[2]; + p[0].op = OP_ArrayElement; + p[1].i = i; + gl_add_op(p); +} + + +void +glopEnableClientState(GLContext *c, GLParam *p) +{ + c->client_states |= p[1].i; +} + +void +glEnableClientState(GLenum array) +{ + GLParam p[2]; + p[0].op = OP_EnableClientState; + + switch(array) { + case GL_VERTEX_ARRAY: + p[1].i = VERTEX_ARRAY; + break; + case GL_NORMAL_ARRAY: + p[1].i = NORMAL_ARRAY; + break; + case GL_COLOR_ARRAY: + p[1].i = COLOR_ARRAY; + break; + case GL_TEXTURE_COORD_ARRAY: + p[1].i = TEXCOORD_ARRAY; + break; + default: + gl_assert(0); + break; + } + gl_add_op(p); +} + +void +glopDisableClientState(GLContext *c, GLParam *p) +{ + c->client_states &= p[1].i; +} + +void +glDisableClientState(GLenum array) +{ + GLParam p[2]; + p[0].op = OP_DisableClientState; + + switch(array) { + case GL_VERTEX_ARRAY: + p[1].i = ~VERTEX_ARRAY; + break; + case GL_NORMAL_ARRAY: + p[1].i = ~NORMAL_ARRAY; + break; + case GL_COLOR_ARRAY: + p[1].i = ~COLOR_ARRAY; + break; + case GL_TEXTURE_COORD_ARRAY: + p[1].i = ~TEXCOORD_ARRAY; + break; + default: + gl_assert(0); + break; + } + gl_add_op(p); +} + +void +glopVertexPointer(GLContext *c, GLParam *p) +{ + c->vertex_array_size = p[1].i; + c->vertex_array_stride = p[2].i; + c->vertex_array = p[3].p; +} + +void +glVertexPointer(GLint size, GLenum type, GLsizei stride, + const GLvoid *pointer) +{ + GLParam p[4]; + gl_assert(type == GL_FLOAT); + p[0].op = OP_VertexPointer; + p[1].i = size; + p[2].i = stride; + p[3].p = (void*)pointer; + gl_add_op(p); +} + +void +glopColorPointer(GLContext *c, GLParam *p) +{ + c->color_array_size = p[1].i; + c->color_array_stride = p[2].i; + c->color_array = p[3].p; +} + +void +glColorPointer(GLint size, GLenum type, GLsizei stride, + const GLvoid *pointer) +{ + GLParam p[4]; + gl_assert(type == GL_FLOAT); + p[0].op = OP_ColorPointer; + p[1].i = size; + p[2].i = stride; + p[3].p = (void*)pointer; + gl_add_op(p); +} + +void +glopNormalPointer(GLContext *c, GLParam *p) +{ + c->normal_array_stride = p[1].i; + c->normal_array = p[2].p; +} + +void +glNormalPointer(GLenum type, GLsizei stride, + const GLvoid *pointer) +{ + GLParam p[3]; + gl_assert(type == GL_FLOAT); + p[0].op = OP_NormalPointer; + p[1].i = stride; + p[2].p = (void*)pointer; + gl_add_op(p); +} + +void +glopTexCoordPointer(GLContext *c, GLParam *p) +{ + c->texcoord_array_size = p[1].i; + c->texcoord_array_stride = p[2].i; + c->texcoord_array = p[3].p; +} + +void +glTexCoordPointer(GLint size, GLenum type, GLsizei stride, + const GLvoid *pointer) +{ + GLParam p[4]; + gl_assert(type == GL_FLOAT); + p[0].op = OP_TexCoordPointer; + p[1].i = size; + p[2].i = stride; + p[3].p = (void*)pointer; + gl_add_op(p); +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/clear.c b/3rdparty/tinygl-0.4-ugfx/src/clear.c new file mode 100644 index 00000000..f5b75585 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/clear.c @@ -0,0 +1,30 @@ +#include "zgl.h" + + +void glopClearColor(GLContext *c,GLParam *p) +{ + c->clear_color.v[0]=p[1].f; + c->clear_color.v[1]=p[2].f; + c->clear_color.v[2]=p[3].f; + c->clear_color.v[3]=p[4].f; +} +void glopClearDepth(GLContext *c,GLParam *p) +{ + c->clear_depth=p[1].f; +} + + +void glopClear(GLContext *c,GLParam *p) +{ + int mask=p[1].i; + int z=0; + int r=(int)(c->clear_color.v[0]*65535); + int g=(int)(c->clear_color.v[1]*65535); + int b=(int)(c->clear_color.v[2]*65535); + + /* TODO : correct value of Z */ + + ZB_clear(c->zb,mask & GL_DEPTH_BUFFER_BIT,z, + mask & GL_COLOR_BUFFER_BIT,r,g,b); +} + diff --git a/3rdparty/tinygl-0.4-ugfx/src/clip.c b/3rdparty/tinygl-0.4-ugfx/src/clip.c new file mode 100644 index 00000000..47481fa3 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/clip.c @@ -0,0 +1,445 @@ +#include "zgl.h" + +/* fill triangle profile */ +/* #define PROFILE */ + +#define CLIP_XMIN (1<<0) +#define CLIP_XMAX (1<<1) +#define CLIP_YMIN (1<<2) +#define CLIP_YMAX (1<<3) +#define CLIP_ZMIN (1<<4) +#define CLIP_ZMAX (1<<5) + +void gl_transform_to_viewport(GLContext *c,GLVertex *v) +{ + float winv; + + /* coordinates */ + winv=1.0/v->pc.W; + v->zp.x= (int) ( v->pc.X * winv * c->viewport.scale.X + + c->viewport.trans.X ); + v->zp.y= (int) ( v->pc.Y * winv * c->viewport.scale.Y + + c->viewport.trans.Y ); + v->zp.z= (int) ( v->pc.Z * winv * c->viewport.scale.Z + + c->viewport.trans.Z ); + /* color */ + if (c->lighting_enabled) { + v->zp.r=(int)(v->color.v[0] * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) + + ZB_POINT_RED_MIN); + v->zp.g=(int)(v->color.v[1] * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) + + ZB_POINT_GREEN_MIN); + v->zp.b=(int)(v->color.v[2] * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) + + ZB_POINT_BLUE_MIN); + } else { + /* no need to convert to integer if no lighting : take current color */ + v->zp.r = c->longcurrent_color[0]; + v->zp.g = c->longcurrent_color[1]; + v->zp.b = c->longcurrent_color[2]; + } + + /* texture */ + + if (c->texture_2d_enabled) { + v->zp.s=(int)(v->tex_coord.X * (ZB_POINT_S_MAX - ZB_POINT_S_MIN) + + ZB_POINT_S_MIN); + v->zp.t=(int)(v->tex_coord.Y * (ZB_POINT_T_MAX - ZB_POINT_T_MIN) + + ZB_POINT_T_MIN); + } +} + + +static void gl_add_select1(GLContext *c,int z1,int z2,int z3) +{ + unsigned int min,max; + min=max=z1; + if ((unsigned int)z2max) max=z2; + if ((unsigned int)z3>max) max=z3; + + gl_add_select(c,0xffffffff-min,0xffffffff-max); +} + +/* point */ + +void gl_draw_point(GLContext *c,GLVertex *p0) +{ + if (p0->clip_code == 0) { + if (c->render_mode == GL_SELECT) { + gl_add_select(c,p0->zp.z,p0->zp.z); + } else { + ZB_plot(c->zb,&p0->zp); + } + } +} + +/* line */ + +static inline void line_interpolate(GLVertex *q,GLVertex *p0,GLVertex *p1,float t) +{ + q->pc.X=p0->pc.X+(p1->pc.X-p0->pc.X)*t; + q->pc.Y=p0->pc.Y+(p1->pc.Y-p0->pc.Y)*t; + q->pc.Z=p0->pc.Z+(p1->pc.Z-p0->pc.Z)*t; + q->pc.W=p0->pc.W+(p1->pc.W-p0->pc.W)*t; + + q->color.v[0]=p0->color.v[0] + (p1->color.v[0]-p0->color.v[0])*t; + q->color.v[1]=p0->color.v[1] + (p1->color.v[1]-p0->color.v[1])*t; + q->color.v[2]=p0->color.v[2] + (p1->color.v[2]-p0->color.v[2])*t; +} + +/* + * Line Clipping + */ + +/* Line Clipping algorithm from 'Computer Graphics', Principles and + Practice */ +static inline int ClipLine1(float denom,float num,float *tmin,float *tmax) +{ + float t; + + if (denom>0) { + t=num/denom; + if (t>*tmax) return 0; + if (t>*tmin) *tmin=t; + } else if (denom<0) { + t=num/denom; + if (t<*tmin) return 0; + if (t<*tmax) *tmax=t; + } else if (num>0) return 0; + return 1; +} + +void gl_draw_line(GLContext *c,GLVertex *p1,GLVertex *p2) +{ + float dx,dy,dz,dw,x1,y1,z1,w1; + float tmin,tmax; + GLVertex q1,q2; + int cc1,cc2; + + cc1=p1->clip_code; + cc2=p2->clip_code; + + if ( (cc1 | cc2) == 0) { + if (c->render_mode == GL_SELECT) { + gl_add_select1(c,p1->zp.z,p2->zp.z,p2->zp.z); + } else { + if (c->depth_test) + ZB_line_z(c->zb,&p1->zp,&p2->zp); + else + ZB_line(c->zb,&p1->zp,&p2->zp); + } + } else if ( (cc1&cc2) != 0 ) { + return; + } else { + dx=p2->pc.X-p1->pc.X; + dy=p2->pc.Y-p1->pc.Y; + dz=p2->pc.Z-p1->pc.Z; + dw=p2->pc.W-p1->pc.W; + x1=p1->pc.X; + y1=p1->pc.Y; + z1=p1->pc.Z; + w1=p1->pc.W; + + tmin=0; + tmax=1; + if (ClipLine1(dx+dw,-x1-w1,&tmin,&tmax) && + ClipLine1(-dx+dw,x1-w1,&tmin,&tmax) && + ClipLine1(dy+dw,-y1-w1,&tmin,&tmax) && + ClipLine1(-dy+dw,y1-w1,&tmin,&tmax) && + ClipLine1(dz+dw,-z1-w1,&tmin,&tmax) && + ClipLine1(-dz+dw,z1-w1,&tmin,&tmax)) { + + line_interpolate(&q1,p1,p2,tmin); + line_interpolate(&q2,p1,p2,tmax); + gl_transform_to_viewport(c,&q1); + gl_transform_to_viewport(c,&q2); + + if (c->depth_test) + ZB_line_z(c->zb,&q1.zp,&q2.zp); + else + ZB_line(c->zb,&q1.zp,&q2.zp); + } + } +} + + +/* triangle */ + +/* + * Clipping + */ + +/* We clip the segment [a,b] against the 6 planes of the normal volume. + * We compute the point 'c' of intersection and the value of the parameter 't' + * of the intersection if x=a+t(b-a). + */ + +#define clip_func(name,sign,dir,dir1,dir2) \ +static float name(V4 *c,V4 *a,V4 *b) \ +{\ + float t,dX,dY,dZ,dW,den;\ + dX = (b->X - a->X);\ + dY = (b->Y - a->Y);\ + dZ = (b->Z - a->Z);\ + dW = (b->W - a->W);\ + den = -(sign d ## dir) + dW;\ + if (den == 0) t=0;\ + else t = ( sign a->dir - a->W) / den;\ + c->dir1 = a->dir1 + t * d ## dir1;\ + c->dir2 = a->dir2 + t * d ## dir2;\ + c->W = a->W + t * dW;\ + c->dir = sign c->W;\ + return t;\ +} + + +clip_func(clip_xmin,-,X,Y,Z) + +clip_func(clip_xmax,+,X,Y,Z) + +clip_func(clip_ymin,-,Y,X,Z) + +clip_func(clip_ymax,+,Y,X,Z) + +clip_func(clip_zmin,-,Z,X,Y) + +clip_func(clip_zmax,+,Z,X,Y) + + +float (*clip_proc[6])(V4 *,V4 *,V4 *)= { + clip_xmin,clip_xmax, + clip_ymin,clip_ymax, + clip_zmin,clip_zmax +}; + +static inline void updateTmp(GLContext *c, + GLVertex *q,GLVertex *p0,GLVertex *p1,float t) +{ + if (c->current_shade_model == GL_SMOOTH) { + q->color.v[0]=p0->color.v[0] + (p1->color.v[0]-p0->color.v[0])*t; + q->color.v[1]=p0->color.v[1] + (p1->color.v[1]-p0->color.v[1])*t; + q->color.v[2]=p0->color.v[2] + (p1->color.v[2]-p0->color.v[2])*t; + } else { + q->color.v[0]=p0->color.v[0]; + q->color.v[1]=p0->color.v[1]; + q->color.v[2]=p0->color.v[2]; + } + + if (c->texture_2d_enabled) { + q->tex_coord.X=p0->tex_coord.X + (p1->tex_coord.X-p0->tex_coord.X)*t; + q->tex_coord.Y=p0->tex_coord.Y + (p1->tex_coord.Y-p0->tex_coord.Y)*t; + } + + q->clip_code=gl_clipcode(q->pc.X,q->pc.Y,q->pc.Z,q->pc.W); + if (q->clip_code==0) + gl_transform_to_viewport(c,q); +} + +static void gl_draw_triangle_clip(GLContext *c, + GLVertex *p0,GLVertex *p1,GLVertex *p2,int clip_bit); + +void gl_draw_triangle(GLContext *c, + GLVertex *p0,GLVertex *p1,GLVertex *p2) +{ + int co,c_and,cc[3],front; + float norm; + + cc[0]=p0->clip_code; + cc[1]=p1->clip_code; + cc[2]=p2->clip_code; + + co=cc[0] | cc[1] | cc[2]; + + /* we handle the non clipped case here to go faster */ + if (co==0) { + + norm=(float)(p1->zp.x-p0->zp.x)*(float)(p2->zp.y-p0->zp.y)- + (float)(p2->zp.x-p0->zp.x)*(float)(p1->zp.y-p0->zp.y); + + if (norm == 0) return; + + front = norm < 0.0; + front = front ^ c->current_front_face; + + /* back face culling */ + if (c->cull_face_enabled) { + /* most used case first */ + if (c->current_cull_face == GL_BACK) { + if (front == 0) return; + c->draw_triangle_front(c,p0,p1,p2); + } else if (c->current_cull_face == GL_FRONT) { + if (front != 0) return; + c->draw_triangle_back(c,p0,p1,p2); + } else { + return; + } + } else { + /* no culling */ + if (front) { + c->draw_triangle_front(c,p0,p1,p2); + } else { + c->draw_triangle_back(c,p0,p1,p2); + } + } + } else { + c_and=cc[0] & cc[1] & cc[2]; + if (c_and==0) { + gl_draw_triangle_clip(c,p0,p1,p2,0); + } + } +} + +static void gl_draw_triangle_clip(GLContext *c, + GLVertex *p0,GLVertex *p1,GLVertex *p2,int clip_bit) +{ + int co,c_and,co1,cc[3],edge_flag_tmp,clip_mask; + GLVertex tmp1,tmp2,*q[3]; + float tt; + + cc[0]=p0->clip_code; + cc[1]=p1->clip_code; + cc[2]=p2->clip_code; + + co=cc[0] | cc[1] | cc[2]; + if (co == 0) { + gl_draw_triangle(c,p0,p1,p2); + } else { + c_and=cc[0] & cc[1] & cc[2]; + /* the triangle is completely outside */ + if (c_and!=0) return; + + /* find the next direction to clip */ + while (clip_bit < 6 && (co & (1 << clip_bit)) == 0) { + clip_bit++; + } + + /* this test can be true only in case of rounding errors */ + if (clip_bit == 6) { +#if 0 + printf("Error:\n"); + printf("%f %f %f %f\n",p0->pc.X,p0->pc.Y,p0->pc.Z,p0->pc.W); + printf("%f %f %f %f\n",p1->pc.X,p1->pc.Y,p1->pc.Z,p1->pc.W); + printf("%f %f %f %f\n",p2->pc.X,p2->pc.Y,p2->pc.Z,p2->pc.W); +#endif + return; + } + + clip_mask = 1 << clip_bit; + co1=(cc[0] ^ cc[1] ^ cc[2]) & clip_mask; + + if (co1) { + /* one point outside */ + + if (cc[0] & clip_mask) { q[0]=p0; q[1]=p1; q[2]=p2; } + else if (cc[1] & clip_mask) { q[0]=p1; q[1]=p2; q[2]=p0; } + else { q[0]=p2; q[1]=p0; q[2]=p1; } + + tt=clip_proc[clip_bit](&tmp1.pc,&q[0]->pc,&q[1]->pc); + updateTmp(c,&tmp1,q[0],q[1],tt); + + tt=clip_proc[clip_bit](&tmp2.pc,&q[0]->pc,&q[2]->pc); + updateTmp(c,&tmp2,q[0],q[2],tt); + + tmp1.edge_flag=q[0]->edge_flag; + edge_flag_tmp=q[2]->edge_flag; + q[2]->edge_flag=0; + gl_draw_triangle_clip(c,&tmp1,q[1],q[2],clip_bit+1); + + tmp2.edge_flag=1; + tmp1.edge_flag=0; + q[2]->edge_flag=edge_flag_tmp; + gl_draw_triangle_clip(c,&tmp2,&tmp1,q[2],clip_bit+1); + } else { + /* two points outside */ + + if ((cc[0] & clip_mask)==0) { q[0]=p0; q[1]=p1; q[2]=p2; } + else if ((cc[1] & clip_mask)==0) { q[0]=p1; q[1]=p2; q[2]=p0; } + else { q[0]=p2; q[1]=p0; q[2]=p1; } + + tt=clip_proc[clip_bit](&tmp1.pc,&q[0]->pc,&q[1]->pc); + updateTmp(c,&tmp1,q[0],q[1],tt); + + tt=clip_proc[clip_bit](&tmp2.pc,&q[0]->pc,&q[2]->pc); + updateTmp(c,&tmp2,q[0],q[2],tt); + + tmp1.edge_flag=1; + tmp2.edge_flag=q[2]->edge_flag; + gl_draw_triangle_clip(c,q[0],&tmp1,&tmp2,clip_bit+1); + } + } +} + + +void gl_draw_triangle_select(GLContext *c, + GLVertex *p0,GLVertex *p1,GLVertex *p2) +{ + gl_add_select1(c,p0->zp.z,p1->zp.z,p2->zp.z); +} + +#ifdef PROFILE +int count_triangles,count_triangles_textured,count_pixels; +#endif + +void gl_draw_triangle_fill(GLContext *c, + GLVertex *p0,GLVertex *p1,GLVertex *p2) +{ +#ifdef PROFILE + { + int norm; + gl_assert(p0->zp.x >= 0 && p0->zp.x < c->zb->xsize); + gl_assert(p0->zp.y >= 0 && p0->zp.y < c->zb->ysize); + gl_assert(p1->zp.x >= 0 && p1->zp.x < c->zb->xsize); + gl_assert(p1->zp.y >= 0 && p1->zp.y < c->zb->ysize); + gl_assert(p2->zp.x >= 0 && p2->zp.x < c->zb->xsize); + gl_assert(p2->zp.y >= 0 && p2->zp.y < c->zb->ysize); + + norm=(p1->zp.x-p0->zp.x)*(p2->zp.y-p0->zp.y)- + (p2->zp.x-p0->zp.x)*(p1->zp.y-p0->zp.y); + count_pixels+=abs(norm)/2; + count_triangles++; + } +#endif + + if (c->texture_2d_enabled) { +#ifdef PROFILE + count_triangles_textured++; +#endif + ZB_setTexture(c->zb,c->current_texture->images[0].pixmap); + ZB_fillTriangleMappingPerspective(c->zb,&p0->zp,&p1->zp,&p2->zp); + } else if (c->current_shade_model == GL_SMOOTH) { + ZB_fillTriangleSmooth(c->zb,&p0->zp,&p1->zp,&p2->zp); + } else { + ZB_fillTriangleFlat(c->zb,&p0->zp,&p1->zp,&p2->zp); + } +} + +/* Render a clipped triangle in line mode */ + +void gl_draw_triangle_line(GLContext *c, + GLVertex *p0,GLVertex *p1,GLVertex *p2) +{ + if (c->depth_test) { + if (p0->edge_flag) ZB_line_z(c->zb,&p0->zp,&p1->zp); + if (p1->edge_flag) ZB_line_z(c->zb,&p1->zp,&p2->zp); + if (p2->edge_flag) ZB_line_z(c->zb,&p2->zp,&p0->zp); + } else { + if (p0->edge_flag) ZB_line(c->zb,&p0->zp,&p1->zp); + if (p1->edge_flag) ZB_line(c->zb,&p1->zp,&p2->zp); + if (p2->edge_flag) ZB_line(c->zb,&p2->zp,&p0->zp); + } +} + + + +/* Render a clipped triangle in point mode */ +void gl_draw_triangle_point(GLContext *c, + GLVertex *p0,GLVertex *p1,GLVertex *p2) +{ + if (p0->edge_flag) ZB_plot(c->zb,&p0->zp); + if (p1->edge_flag) ZB_plot(c->zb,&p1->zp); + if (p2->edge_flag) ZB_plot(c->zb,&p2->zp); +} + + + + diff --git a/3rdparty/tinygl-0.4-ugfx/src/error.c b/3rdparty/tinygl-0.4-ugfx/src/error.c new file mode 100644 index 00000000..a1c0a6df --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/error.c @@ -0,0 +1,22 @@ +#include +#include +#include "zgl.h" + +void gl_fatal_error(char *format, ...) +{ + va_list ap; + + va_start(ap,format); + + fprintf(stderr,"TinyGL: fatal error: "); + vfprintf(stderr,format,ap); + fprintf(stderr,"\n"); + exit(1); + + va_end(ap); +} + +void gl_assert(int test) +{ + assert(test); +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/get.c b/3rdparty/tinygl-0.4-ugfx/src/get.c new file mode 100644 index 00000000..8cd0d787 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/get.c @@ -0,0 +1,74 @@ +#include "zgl.h" + +void glGetIntegerv(int pname,int *params) +{ + GLContext *c=gl_get_context(); + + switch(pname) { + case GL_VIEWPORT: + params[0]=c->viewport.xmin; + params[1]=c->viewport.ymin; + params[2]=c->viewport.xsize; + params[3]=c->viewport.ysize; + break; + case GL_MAX_MODELVIEW_STACK_DEPTH: + *params = MAX_MODELVIEW_STACK_DEPTH; + break; + case GL_MAX_PROJECTION_STACK_DEPTH: + *params = MAX_PROJECTION_STACK_DEPTH; + break; + case GL_MAX_LIGHTS: + *params = MAX_LIGHTS; + break; + case GL_MAX_TEXTURE_SIZE: + *params = 256; /* not completely true, but... */ + break; + case GL_MAX_TEXTURE_STACK_DEPTH: + *params = MAX_TEXTURE_STACK_DEPTH; + break; + default: + gl_fatal_error("glGet: option not implemented"); + break; + } +} + +void glGetFloatv(int pname, float *v) +{ + int i; + int mnr = 0; /* just a trick to return the correct matrix */ + GLContext *c = gl_get_context(); + switch (pname) { + case GL_TEXTURE_MATRIX: + mnr++; + case GL_PROJECTION_MATRIX: + mnr++; + case GL_MODELVIEW_MATRIX: + { + float *p = &c->matrix_stack_ptr[mnr]->m[0][0];; + for (i = 0; i < 4; i++) { + *v++ = p[0]; + *v++ = p[4]; + *v++ = p[8]; + *v++ = p[12]; + p++; + } + } + break; + case GL_LINE_WIDTH: + *v = 1.0f; + break; + case GL_LINE_WIDTH_RANGE: + v[0] = v[1] = 1.0f; + break; + case GL_POINT_SIZE: + *v = 1.0f; + break; + case GL_POINT_SIZE_RANGE: + v[0] = v[1] = 1.0f; + default: +#ifndef NO_CLIBRARY + fprintf(stderr,"warning: unknown pname in glGetFloatv()\n"); +#endif + break; + } +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/glx.c b/3rdparty/tinygl-0.4-ugfx/src/glx.c new file mode 100644 index 00000000..2c018128 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/glx.c @@ -0,0 +1,413 @@ +/* simple glx driver for TinyGL */ +#include +#include +#include +#include +#include "zgl.h" + +typedef struct { + GLContext *gl_context; + Display *display; + XVisualInfo visual_info; + int xsize,ysize; + XImage *ximage; + GC gc; + Colormap cmap; + Drawable drawable; + int do_convert; /* true if must do convertion to X11 format */ + /* shared memory */ + int shm_use; + XShmSegmentInfo *shm_info; + int CompletionType; +} TinyGLXContext; + +Bool glXQueryExtension( Display *dpy, int *errorb, int *event ) +{ + return True; +} + + +XVisualInfo* glXChooseVisual( Display *dpy, int screen, + int *attribList ) +{ + XVisualInfo vinfo; + int n; + + /* the attribList is ignored : we consider only RGBA rendering (no + direct color) */ + + if (XMatchVisualInfo (dpy, screen, 16, TrueColor, &vinfo)) { + /* 16 bit visual (fastest with TinyGL) */ + } else if (XMatchVisualInfo (dpy, screen, 24, TrueColor, &vinfo)) { + /* 24 bit visual */ + } else if (XMatchVisualInfo (dpy, screen, 32, TrueColor, &vinfo)) { + /* 32 bit visual */ + } else if (XMatchVisualInfo (dpy, screen, 8, PseudoColor, &vinfo)) { + /* 8 bit visual */ + } else { + /* no suitable visual */ + return NULL; + } + + return XGetVisualInfo(dpy,VisualAllMask,&vinfo,&n); +} + + + +GLXContext glXCreateContext( Display *dpy, XVisualInfo *vis, + GLXContext shareList, Bool direct ) +{ + TinyGLXContext *ctx; + + if (shareList != NULL) { + gl_fatal_error("No sharing available in TinyGL"); + } + ctx=gl_malloc(sizeof(TinyGLXContext)); + ctx->gl_context=NULL; + ctx->visual_info=*vis; + return (GLXContext) ctx; +} + + +void glXDestroyContext( Display *dpy, GLXContext ctx1 ) +{ + TinyGLXContext *ctx = (TinyGLXContext *) ctx1; + if (ctx->gl_context != NULL) { + glClose(); + } + gl_free(ctx); +} + + +static int glxXErrorFlag=0; + +static int glxHandleXError(Display *dpy,XErrorEvent *event) +{ + glxXErrorFlag=1; + return 0; +} + +static int bits_per_pixel(Display *dpy, XVisualInfo *visinfo) +{ + XImage *img; + int bpp; + char *data; + + data = gl_malloc(8); + if (data == NULL) + return visinfo->depth; + + img = XCreateImage(dpy, visinfo->visual, visinfo->depth, + ZPixmap, 0, data, 1, 1, 32, 0); + if (img == NULL) { + gl_free(data); + return visinfo->depth; + } + bpp = img->bits_per_pixel; + gl_free(data); + img->data = NULL; + XDestroyImage(img); + return bpp; +} + +static int create_ximage(TinyGLXContext *ctx, + int xsize,int ysize,int depth) +{ + int major,minor; + Bool pixmaps; + unsigned char *framebuffer; + int (*old_handler)(Display *,XErrorEvent *); + + if (XShmQueryVersion(ctx->display,&major,&minor,&pixmaps)) + ctx->shm_use=1; + else + ctx->shm_use=0; + + if (!ctx->shm_use) goto no_shm; + + ctx->shm_info=gl_malloc(sizeof(XShmSegmentInfo)); + ctx->ximage=XShmCreateImage(ctx->display,None,depth,ZPixmap,NULL, + ctx->shm_info,xsize,ysize); + if (ctx->ximage == NULL) { + fprintf(stderr,"XShm: error: XShmCreateImage\n"); + ctx->shm_use=0; + gl_free(ctx->shm_info); + goto no_shm; + } + ctx->shm_info->shmid=shmget(IPC_PRIVATE, + ctx->ysize*ctx->ximage->bytes_per_line, + IPC_CREAT | 0777); + if (ctx->shm_info->shmid < 0) { + fprintf(stderr,"XShm: error: shmget\n"); + no_shm1: + ctx->shm_use=0; + XDestroyImage(ctx->ximage); + goto no_shm; + } + ctx->ximage->data=shmat(ctx->shm_info->shmid,0,0); + if (ctx->ximage->data == (char *) -1) { + fprintf(stderr,"XShm: error: shmat\n"); + no_shm2: + shmctl(ctx->shm_info->shmid,IPC_RMID,0); + goto no_shm1; + } + ctx->shm_info->shmaddr=ctx->ximage->data; + + ctx->shm_info->readOnly=False; + + /* attach & test X errors */ + + glxXErrorFlag=0; + old_handler=XSetErrorHandler(glxHandleXError); + XShmAttach(ctx->display,ctx->shm_info); + XSync(ctx->display, False); + + if (glxXErrorFlag) { + XFlush(ctx->display); + shmdt(ctx->shm_info->shmaddr); + XSetErrorHandler(old_handler); + goto no_shm2; + } + + /* the shared memory will be automatically deleted */ + shmctl(ctx->shm_info->shmid,IPC_RMID,0); + + /* test with a dummy XShmPutImage */ + XShmPutImage(ctx->display,ctx->drawable,ctx->gc, + ctx->ximage,0,0,0,0,1,1, + False); + + XSync(ctx->display, False); + XSetErrorHandler(old_handler); + + if (glxXErrorFlag) { + fprintf(stderr,"XShm: error: XShmPutImage\n"); + XFlush(ctx->display); + shmdt(ctx->shm_info->shmaddr); + goto no_shm2; + } + + ctx->CompletionType=XShmGetEventBase(ctx->display) + ShmCompletion; + /* shared memory is OK !! */ + + return 0; + + no_shm: + ctx->ximage=XCreateImage(ctx->display, None, depth, ZPixmap, 0, + NULL,xsize,ysize, 8, 0); + framebuffer=gl_malloc(ysize * ctx->ximage->bytes_per_line); + ctx->ximage->data = framebuffer; + return 0; +} + +static void free_ximage(TinyGLXContext *ctx) +{ + if (ctx->shm_use) + { + XShmDetach(ctx->display, ctx->shm_info); + XDestroyImage(ctx->ximage); + shmdt(ctx->shm_info->shmaddr); + gl_free(ctx->shm_info); + } else { + gl_free(ctx->ximage->data); + XDestroyImage(ctx->ximage); + } +} + +/* resize the glx viewport : we try to use the xsize and ysize + given. We return the effective size which is guaranted to be smaller */ + +int glX_resize_viewport(GLContext *c,int *xsize_ptr,int *ysize_ptr) +{ + TinyGLXContext *ctx; + int xsize,ysize; + + ctx=(TinyGLXContext *)c->opaque; + + xsize=*xsize_ptr; + ysize=*ysize_ptr; + + /* we ensure that xsize and ysize are multiples of 2 for the zbuffer. + TODO: find a better solution */ + xsize&=~3; + ysize&=~3; + + if (xsize == 0 || ysize == 0) return -1; + + *xsize_ptr=xsize; + *ysize_ptr=ysize; + + if (ctx->ximage != NULL) free_ximage(ctx); + + ctx->xsize=xsize; + ctx->ysize=ysize; + + if (create_ximage(ctx,ctx->xsize,ctx->ysize,ctx->visual_info.depth) != 0) + return -1; + + /* resize the Z buffer */ + if (ctx->do_convert) { + ZB_resize(c->zb,NULL,xsize,ysize); + } else { + ZB_resize(c->zb,ctx->ximage->data,xsize,ysize); + } + return 0; +} + +/* we assume here that drawable is a window */ +Bool glXMakeCurrent( Display *dpy, GLXDrawable drawable, + GLXContext ctx1) +{ + TinyGLXContext *ctx = (TinyGLXContext *) ctx1; + XWindowAttributes attr; + int i,xsize,ysize; + unsigned int palette[ZB_NB_COLORS]; + unsigned char color_indexes[ZB_NB_COLORS]; + ZBuffer *zb; + XColor xcolor; + unsigned long pixel[ZB_NB_COLORS],tmp_plane; + + if (ctx->gl_context == NULL) { + /* create the TinyGL context */ + + ctx->display=dpy; + ctx->drawable=drawable; + + XGetWindowAttributes(ctx->display,drawable,&attr); + + xsize=attr.width; + ysize=attr.height; + + if (attr.depth != ctx->visual_info.depth) return False; + + /* ximage structure */ + ctx->ximage=NULL; + ctx->shm_use=1; /* use shm */ + + if (attr.depth == 8) { + /* get the colormap from the window */ + ctx->cmap = attr.colormap; + + if ( XAllocColorCells(ctx->display,ctx->cmap,True,&tmp_plane,0, + pixel,ZB_NB_COLORS) == 0) { + /* private cmap */ + ctx->cmap = XCreateColormap(ctx->display, drawable, + ctx->visual_info.visual, AllocAll); + XSetWindowColormap(ctx->display, drawable, ctx->cmap); + for(i=0;i>8) & 0xFF00; + xcolor.green = (palette[i] & 0xFF00); + xcolor.blue = (palette[i] << 8) & 0xFF00; + xcolor.pixel = pixel[i]; + XStoreColor(ctx->display,ctx->cmap,&xcolor); + } + ctx->do_convert = 1; + } else { + int mode,bpp; + /* RGB 16/24/32 */ + bpp = bits_per_pixel(ctx->display,&ctx->visual_info); + switch(bpp) { + case 24: + mode = ZB_MODE_RGB24; + ctx->do_convert = (TGL_FEATURE_RENDER_BITS != 16); + break; + case 32: + mode = ZB_MODE_RGBA; + ctx->do_convert = (TGL_FEATURE_RENDER_BITS != 16); + break; + default: + mode = ZB_MODE_5R6G5B; + ctx->do_convert = (TGL_FEATURE_RENDER_BITS != 16); + break; + } + zb=ZB_open(xsize,ysize,mode,0,NULL,NULL,NULL); + if (zb == NULL) { + fprintf(stderr, "Error while initializing Z buffer\n"); + exit(1); + } + } + + /* create a gc */ + ctx->gc = XCreateGC(ctx->display, drawable, 0, 0); + + /* initialisation of the TinyGL interpreter */ + glInit(zb); + ctx->gl_context=gl_get_context(); + ctx->gl_context->opaque=(void *) ctx; + ctx->gl_context->gl_resize_viewport=glX_resize_viewport; + + /* set the viewport : we force a call to glX_resize_viewport */ + ctx->gl_context->viewport.xsize=-1; + ctx->gl_context->viewport.ysize=-1; + + glViewport(0, 0, xsize, ysize); + } + + return True; +} + +static Bool WaitForShmCompletion(Display *dpy, XEvent *event, char *arg) +{ + TinyGLXContext *ctx=(TinyGLXContext *) arg; + + return (event->type == ctx->CompletionType) && + ( ((XShmCompletionEvent *)event)->drawable == (Window)ctx->drawable); +} + +void glXSwapBuffers( Display *dpy, GLXDrawable drawable ) +{ + GLContext *gl_context; + TinyGLXContext *ctx; + + /* retrieve the current GLXContext */ + gl_context=gl_get_context(); + ctx=(TinyGLXContext *)gl_context->opaque; + + /* for non 16 bits visuals, a conversion is required */ + + + if (ctx->do_convert) { + ZB_copyFrameBuffer(ctx->gl_context->zb, + ctx->ximage->data, + ctx->ximage->bytes_per_line); + + } + + /* draw the ximage */ + if (ctx->shm_use) { + XEvent event; + + XShmPutImage(dpy,drawable,ctx->gc, + ctx->ximage,0,0,0,0,ctx->ximage->width, ctx->ximage->height, + True); + XIfEvent(dpy, &event, WaitForShmCompletion, (char*)ctx); + } else { + XPutImage(dpy, drawable, ctx->gc, + ctx->ximage, 0, 0, 0, 0, ctx->ximage->width, ctx->ximage->height); + } + XFlush(dpy); +} + + +void glXWaitGL( void ) +{ +} + +void glXWaitX( void ) +{ +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/image_util.c b/3rdparty/tinygl-0.4-ugfx/src/image_util.c new file mode 100644 index 00000000..2789a55c --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/image_util.c @@ -0,0 +1,136 @@ +#include "zgl.h" + +/* + * image conversion + */ + +void gl_convertRGB_to_5R6G5B(unsigned short *pixmap,unsigned char *rgb, + int xsize,int ysize) +{ + int i,n; + unsigned char *p; + + p=rgb; + n=xsize*ysize; + for(i=0;i>3); + p+=3; + } +} + +void gl_convertRGB_to_8A8R8G8B(unsigned int *pixmap, unsigned char *rgb, + int xsize, int ysize) +{ + int i,n; + unsigned char *p; + + p=rgb; + n=xsize*ysize; + for(i=0;i> INTERP_NORM_BITS); +} + + +/* + * TODO: more accurate resampling + */ + +void gl_resizeImage(unsigned char *dest,int xsize_dest,int ysize_dest, + unsigned char *src,int xsize_src,int ysize_src) +{ + unsigned char *pix,*pix_src; + float x1,y1,x1inc,y1inc; + int xi,yi,j,xf,yf,x,y; + + pix=dest; + pix_src=src; + + x1inc=(float) (xsize_src - 1) / (float) (xsize_dest - 1); + y1inc=(float) (ysize_src - 1) / (float) (ysize_dest - 1); + + y1=0; + for(y=0;y> FRAC_BITS; + yi=y1 >> FRAC_BITS; + pix1=pix_src+(yi*xsize_src+xi)*3; + + pix[0]=pix1[0]; + pix[1]=pix1[1]; + pix[2]=pix1[2]; + + pix+=3; + x1+=x1inc; + } + y1+=y1inc; + } +} + diff --git a/3rdparty/tinygl-0.4-ugfx/src/init.c b/3rdparty/tinygl-0.4-ugfx/src/init.c new file mode 100644 index 00000000..edc7a4c3 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/init.c @@ -0,0 +1,189 @@ +#include "zgl.h" + +GLContext *gl_ctx; + + +void initSharedState(GLContext *c) +{ + GLSharedState *s=&c->shared_state; + s->lists=gl_zalloc(sizeof(GLList *) * MAX_DISPLAY_LISTS); + s->texture_hash_table= + gl_zalloc(sizeof(GLTexture *) * TEXTURE_HASH_TABLE_SIZE); + + alloc_texture(c,0); +} + +void endSharedState(GLContext *c) +{ + GLSharedState *s=&c->shared_state; + int i; + + for(i=0;ilists); + + gl_free(s->texture_hash_table); +} + + +void glInit(void *zbuffer1) +{ + ZBuffer *zbuffer=(ZBuffer *)zbuffer1; + GLContext *c; + GLViewport *v; + int i; + + c=gl_zalloc(sizeof(GLContext)); + gl_ctx=c; + + c->zb=zbuffer; + + /* allocate GLVertex array */ + c->vertex_max = POLYGON_MAX_VERTEX; + c->vertex = gl_malloc(POLYGON_MAX_VERTEX*sizeof(GLVertex)); + + /* viewport */ + v=&c->viewport; + v->xmin=0; + v->ymin=0; + v->xsize=zbuffer->xsize; + v->ysize=zbuffer->ysize; + v->updated=1; + + /* shared state */ + initSharedState(c); + + /* lists */ + + c->exec_flag=1; + c->compile_flag=0; + c->print_flag=0; + + c->in_begin=0; + + /* lights */ + for(i=0;ilights[i]; + l->ambient=gl_V4_New(0,0,0,1); + l->diffuse=gl_V4_New(1,1,1,1); + l->specular=gl_V4_New(1,1,1,1); + l->position=gl_V4_New(0,0,1,0); + l->norm_position=gl_V3_New(0,0,1); + l->spot_direction=gl_V3_New(0,0,-1); + l->norm_spot_direction=gl_V3_New(0,0,-1); + l->spot_exponent=0; + l->spot_cutoff=180; + l->attenuation[0]=1; + l->attenuation[1]=0; + l->attenuation[2]=0; + l->enabled=0; + } + c->first_light=NULL; + c->ambient_light_model=gl_V4_New(0.2,0.2,0.2,1); + c->local_light_model=0; + c->lighting_enabled=0; + c->light_model_two_side = 0; + + /* default materials */ + for(i=0;i<2;i++) { + GLMaterial *m=&c->materials[i]; + m->emission=gl_V4_New(0,0,0,1); + m->ambient=gl_V4_New(0.2,0.2,0.2,1); + m->diffuse=gl_V4_New(0.8,0.8,0.8,1); + m->specular=gl_V4_New(0,0,0,1); + m->shininess=0; + } + c->current_color_material_mode=GL_FRONT_AND_BACK; + c->current_color_material_type=GL_AMBIENT_AND_DIFFUSE; + c->color_material_enabled=0; + + /* textures */ + glInitTextures(c); + + /* default state */ + c->current_color.X=1.0; + c->current_color.Y=1.0; + c->current_color.Z=1.0; + c->current_color.W=1.0; + c->longcurrent_color[0] = 65535; + c->longcurrent_color[1] = 65535; + c->longcurrent_color[2] = 65535; + + c->current_normal.X=1.0; + c->current_normal.Y=0.0; + c->current_normal.Z=0.0; + c->current_normal.W=0.0; + + c->current_edge_flag=1; + + c->current_tex_coord.X=0; + c->current_tex_coord.Y=0; + c->current_tex_coord.Z=0; + c->current_tex_coord.W=1; + + c->polygon_mode_front=GL_FILL; + c->polygon_mode_back=GL_FILL; + + c->current_front_face=0; /* 0 = GL_CCW 1 = GL_CW */ + c->current_cull_face=GL_BACK; + c->current_shade_model=GL_SMOOTH; + c->cull_face_enabled=0; + + /* clear */ + c->clear_color.v[0]=0; + c->clear_color.v[1]=0; + c->clear_color.v[2]=0; + c->clear_color.v[3]=0; + c->clear_depth=0; + + /* selection */ + c->render_mode=GL_RENDER; + c->select_buffer=NULL; + c->name_stack_size=0; + + /* matrix */ + c->matrix_mode=0; + + c->matrix_stack_depth_max[0]=MAX_MODELVIEW_STACK_DEPTH; + c->matrix_stack_depth_max[1]=MAX_PROJECTION_STACK_DEPTH; + c->matrix_stack_depth_max[2]=MAX_TEXTURE_STACK_DEPTH; + + for(i=0;i<3;i++) { + c->matrix_stack[i]=gl_zalloc(c->matrix_stack_depth_max[i] * sizeof(M4)); + c->matrix_stack_ptr[i]=c->matrix_stack[i]; + } + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glMatrixMode(GL_TEXTURE); + glLoadIdentity(); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + c->matrix_model_projection_updated=1; + + /* opengl 1.1 arrays */ + c->client_states = 0; + + /* opengl 1.1 polygon offset */ + c->offset_states = 0; + + /* clear the resize callback function pointer */ + c->gl_resize_viewport = NULL; + + /* specular buffer */ + c->specbuf_first = NULL; + c->specbuf_used_counter = 0; + c->specbuf_num_buffers = 0; + + /* depth test */ + c->depth_test = 0; +} + +void glClose(void) +{ + GLContext *c=gl_get_context(); + endSharedState(c); + gl_free(c); +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/light.c b/3rdparty/tinygl-0.4-ugfx/src/light.c new file mode 100644 index 00000000..a0eeca2d --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/light.c @@ -0,0 +1,306 @@ +#include "zgl.h" +#include "msghandling.h" + +void glopMaterial(GLContext *c,GLParam *p) +{ + int mode=p[1].i; + int type=p[2].i; + float *v=&p[3].f; + int i; + GLMaterial *m; + + if (mode == GL_FRONT_AND_BACK) { + p[1].i=GL_FRONT; + glopMaterial(c,p); + mode=GL_BACK; + } + if (mode == GL_FRONT) m=&c->materials[0]; + else m=&c->materials[1]; + + switch(type) { + case GL_EMISSION: + for(i=0;i<4;i++) + m->emission.v[i]=v[i]; + break; + case GL_AMBIENT: + for(i=0;i<4;i++) + m->ambient.v[i]=v[i]; + break; + case GL_DIFFUSE: + for(i=0;i<4;i++) + m->diffuse.v[i]=v[i]; + break; + case GL_SPECULAR: + for(i=0;i<4;i++) + m->specular.v[i]=v[i]; + break; + case GL_SHININESS: + m->shininess=v[0]; + m->shininess_i = (v[0]/128.0f)*SPECULAR_BUFFER_RESOLUTION; + break; + case GL_AMBIENT_AND_DIFFUSE: + for(i=0;i<4;i++) + m->diffuse.v[i]=v[i]; + for(i=0;i<4;i++) + m->ambient.v[i]=v[i]; + break; + default: + gl_assert(0); + } +} + +void glopColorMaterial(GLContext *c,GLParam *p) +{ + int mode=p[1].i; + int type=p[2].i; + + c->current_color_material_mode=mode; + c->current_color_material_type=type; +} + +void glopLight(GLContext *c,GLParam *p) +{ + int light=p[1].i; + int type=p[2].i; + V4 v; + GLLight *l; + int i; + + gl_assert(light >= GL_LIGHT0 && light < GL_LIGHT0+MAX_LIGHTS ); + + l=&c->lights[light-GL_LIGHT0]; + + for(i=0;i<4;i++) v.v[i]=p[3+i].f; + + switch(type) { + case GL_AMBIENT: + l->ambient=v; + break; + case GL_DIFFUSE: + l->diffuse=v; + break; + case GL_SPECULAR: + l->specular=v; + break; + case GL_POSITION: + { + V4 pos; + gl_M4_MulV4(&pos,c->matrix_stack_ptr[0],&v); + + l->position=pos; + + if (l->position.v[3] == 0) { + l->norm_position.X=pos.X; + l->norm_position.Y=pos.Y; + l->norm_position.Z=pos.Z; + + gl_V3_Norm(&l->norm_position); + } + } + break; + case GL_SPOT_DIRECTION: + for(i=0;i<3;i++) { + l->spot_direction.v[i]=v.v[i]; + l->norm_spot_direction.v[i]=v.v[i]; + } + gl_V3_Norm(&l->norm_spot_direction); + break; + case GL_SPOT_EXPONENT: + l->spot_exponent=v.v[0]; + break; + case GL_SPOT_CUTOFF: + { + float a=v.v[0]; + gl_assert(a == 180 || (a>=0 && a<=90)); + l->spot_cutoff=a; + if (a != 180) l->cos_spot_cutoff=cos(a * M_PI / 180.0); + } + break; + case GL_CONSTANT_ATTENUATION: + l->attenuation[0]=v.v[0]; + break; + case GL_LINEAR_ATTENUATION: + l->attenuation[1]=v.v[0]; + break; + case GL_QUADRATIC_ATTENUATION: + l->attenuation[2]=v.v[0]; + break; + default: + gl_assert(0); + } +} + + +void glopLightModel(GLContext *c,GLParam *p) +{ + int pname=p[1].i; + float *v=&p[2].f; + int i; + + switch(pname) { + case GL_LIGHT_MODEL_AMBIENT: + for(i=0;i<4;i++) + c->ambient_light_model.v[i]=v[i]; + break; + case GL_LIGHT_MODEL_LOCAL_VIEWER: + c->local_light_model=(int)v[0]; + break; + case GL_LIGHT_MODEL_TWO_SIDE: + c->light_model_two_side = (int)v[0]; + break; + default: + tgl_warning("glopLightModel: illegal pname: 0x%x\n", pname); + //gl_assert(0); + break; + } +} + + +static inline float clampf(float a,float min,float max) +{ + if (amax) return max; + else return a; +} + +void gl_enable_disable_light(GLContext *c,int light,int v) +{ + GLLight *l=&c->lights[light]; + if (v && !l->enabled) { + l->enabled=1; + l->next=c->first_light; + c->first_light=l; + l->prev=NULL; + } else if (!v && l->enabled) { + l->enabled=0; + if (l->prev == NULL) c->first_light=l->next; + else l->prev->next=l->next; + if (l->next != NULL) l->next->prev=l->prev; + } +} + +/* non optimized lightening model */ +void gl_shade_vertex(GLContext *c,GLVertex *v) +{ + float R,G,B,A; + GLMaterial *m; + GLLight *l; + V3 n,s,d; + float dist,tmp,att,dot,dot_spot,dot_spec; + int twoside = c->light_model_two_side; + + m=&c->materials[0]; + + n.X=v->normal.X; + n.Y=v->normal.Y; + n.Z=v->normal.Z; + + R=m->emission.v[0]+m->ambient.v[0]*c->ambient_light_model.v[0]; + G=m->emission.v[1]+m->ambient.v[1]*c->ambient_light_model.v[1]; + B=m->emission.v[2]+m->ambient.v[2]*c->ambient_light_model.v[2]; + A=clampf(m->diffuse.v[3],0,1); + + for(l=c->first_light;l!=NULL;l=l->next) { + float lR,lB,lG; + + /* ambient */ + lR=l->ambient.v[0] * m->ambient.v[0]; + lG=l->ambient.v[1] * m->ambient.v[1]; + lB=l->ambient.v[2] * m->ambient.v[2]; + + if (l->position.v[3] == 0) { + /* light at infinity */ + d.X=l->position.v[0]; + d.Y=l->position.v[1]; + d.Z=l->position.v[2]; + att=1; + } else { + /* distance attenuation */ + d.X=l->position.v[0]-v->ec.v[0]; + d.Y=l->position.v[1]-v->ec.v[1]; + d.Z=l->position.v[2]-v->ec.v[2]; + dist=sqrt(d.X*d.X+d.Y*d.Y+d.Z*d.Z); + if (dist>1E-3) { + tmp=1/dist; + d.X*=tmp; + d.Y*=tmp; + d.Z*=tmp; + } + att=1.0f/(l->attenuation[0]+dist*(l->attenuation[1]+ + dist*l->attenuation[2])); + } + dot=d.X*n.X+d.Y*n.Y+d.Z*n.Z; + if (twoside && dot < 0) dot = -dot; + if (dot>0) { + /* diffuse light */ + lR+=dot * l->diffuse.v[0] * m->diffuse.v[0]; + lG+=dot * l->diffuse.v[1] * m->diffuse.v[1]; + lB+=dot * l->diffuse.v[2] * m->diffuse.v[2]; + + /* spot light */ + if (l->spot_cutoff != 180) { + dot_spot=-(d.X*l->norm_spot_direction.v[0]+ + d.Y*l->norm_spot_direction.v[1]+ + d.Z*l->norm_spot_direction.v[2]); + if (twoside && dot_spot < 0) dot_spot = -dot_spot; + if (dot_spot < l->cos_spot_cutoff) { + /* no contribution */ + continue; + } else { + /* TODO: optimize */ + if (l->spot_exponent > 0) { + att=att*pow(dot_spot,l->spot_exponent); + } + } + } + + /* specular light */ + + if (c->local_light_model) { + V3 vcoord; + vcoord.X=v->ec.X; + vcoord.Y=v->ec.Y; + vcoord.Z=v->ec.Z; + gl_V3_Norm(&vcoord); + s.X=d.X-vcoord.X; + s.Y=d.Y-vcoord.X; + s.Z=d.Z-vcoord.X; + } else { + s.X=d.X; + s.Y=d.Y; + s.Z=d.Z+1.0; + } + dot_spec=n.X*s.X+n.Y*s.Y+n.Z*s.Z; + if (twoside && dot_spec < 0) dot_spec = -dot_spec; + if (dot_spec>0) { + GLSpecBuf *specbuf; + int idx; + tmp=sqrt(s.X*s.X+s.Y*s.Y+s.Z*s.Z); + if (tmp > 1E-3) { + dot_spec=dot_spec / tmp; + } + + /* TODO: optimize */ + /* testing specular buffer code */ + /* dot_spec= pow(dot_spec,m->shininess);*/ + specbuf = specbuf_get_buffer(c, m->shininess_i, m->shininess); + idx = (int)(dot_spec*SPECULAR_BUFFER_SIZE); + if (idx > SPECULAR_BUFFER_SIZE) idx = SPECULAR_BUFFER_SIZE; + dot_spec = specbuf->buf[idx]; + lR+=dot_spec * l->specular.v[0] * m->specular.v[0]; + lG+=dot_spec * l->specular.v[1] * m->specular.v[1]; + lB+=dot_spec * l->specular.v[2] * m->specular.v[2]; + } + } + + R+=att * lR; + G+=att * lG; + B+=att * lB; + } + + v->color.v[0]=clampf(R,0,1); + v->color.v[1]=clampf(G,0,1); + v->color.v[2]=clampf(B,0,1); + v->color.v[3]=A; +} + diff --git a/3rdparty/tinygl-0.4-ugfx/src/list.c b/3rdparty/tinygl-0.4-ugfx/src/list.c new file mode 100644 index 00000000..b8d84137 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/list.c @@ -0,0 +1,263 @@ +#include "zgl.h" + +static char *op_table_str[]= +{ +#define ADD_OP(a,b,c) "gl" #a " " #c, + +#include "opinfo.h" +}; + +static void (*op_table_func[])(GLContext *,GLParam *)= +{ +#define ADD_OP(a,b,c) glop ## a , + +#include "opinfo.h" +}; + +static int op_table_size[]= +{ +#define ADD_OP(a,b,c) b + 1 , + +#include "opinfo.h" +}; + + +GLContext *gl_get_context(void) +{ + return gl_ctx; +} + +static GLList *find_list(GLContext *c,unsigned int list) +{ + return c->shared_state.lists[list]; +} + +static void delete_list(GLContext *c,int list) +{ + GLParamBuffer *pb,*pb1; + GLList *l; + + l=find_list(c,list); + gl_assert(l != NULL); + + /* free param buffer */ + pb=l->first_op_buffer; + while (pb!=NULL) { + pb1=pb->next; + gl_free(pb); + pb=pb1; + } + + gl_free(l); + c->shared_state.lists[list]=NULL; +} + +static GLList *alloc_list(GLContext *c,int list) +{ + GLList *l; + GLParamBuffer *ob; + + l=gl_zalloc(sizeof(GLList)); + ob=gl_zalloc(sizeof(GLParamBuffer)); + + ob->next=NULL; + l->first_op_buffer=ob; + + ob->ops[0].op=OP_EndList; + + c->shared_state.lists[list]=l; + return l; +} + + +#ifndef NO_STDIO +void gl_print_op(FILE *f,GLParam *p) +{ + int op; + char *s; + + op=p[0].op; + p++; + s=op_table_str[op]; + while (*s != 0) { + if (*s == '%') { + s++; + switch (*s++) { + case 'f': + fprintf(f,"%g",p[0].f); + break; + default: + fprintf(f,"%d",p[0].i); + break; + } + p++; + } else { + fputc(*s,f); + s++; + } + } + fprintf(f,"\n"); +} +#endif + + +void gl_compile_op(GLContext *c,GLParam *p) +{ + int op,op_size; + GLParamBuffer *ob,*ob1; + int index,i; + + op=p[0].op; + op_size=op_table_size[op]; + index=c->current_op_buffer_index; + ob=c->current_op_buffer; + + /* we should be able to add a NextBuffer opcode */ + if ((index + op_size) > (OP_BUFFER_MAX_SIZE-2)) { + + ob1=gl_zalloc(sizeof(GLParamBuffer)); + ob1->next=NULL; + + ob->next=ob1; + ob->ops[index].op=OP_NextBuffer; + ob->ops[index+1].p=(void *)ob1; + + c->current_op_buffer=ob1; + ob=ob1; + index=0; + } + + for(i=0;iops[index]=p[i]; + index++; + } + c->current_op_buffer_index=index; +} + +void gl_add_op(GLParam *p) +{ + GLContext *c=gl_get_context(); + int op; + + op=p[0].op; + if (c->exec_flag) { + op_table_func[op](c,p); + } + if (c->compile_flag) { + gl_compile_op(c,p); + } +#ifndef NO_CLIBRARY + if (c->print_flag) { + gl_print_op(stderr,p); + } +#endif +} + +/* this opcode is never called directly */ +void glopEndList(GLContext *c,GLParam *p) +{ + (void) c; + (void) p; + gl_assert(0); +} + +/* this opcode is never called directly */ +void glopNextBuffer(GLContext *c,GLParam *p) +{ + (void) c; + (void) p; + gl_assert(0); +} + + +void glopCallList(GLContext *c,GLParam *p) +{ + GLList *l; + int list,op; + + list=p[1].ui; + l=find_list(c,list); + if (l == NULL) gl_fatal_error("list %d not defined",list); + p=l->first_op_buffer->ops; + + while (1) { + op=p[0].op; + if (op == OP_EndList) break; + if (op == OP_NextBuffer) { + p=(GLParam *)p[1].p; + } else { + op_table_func[op](c,p); + p+=op_table_size[op]; + } + } +} + + + +void glNewList(unsigned int list,int mode) +{ + GLList *l; + GLContext *c=gl_get_context(); + + gl_assert(mode == GL_COMPILE || mode == GL_COMPILE_AND_EXECUTE); + gl_assert(c->compile_flag == 0); + + l=find_list(c,list); + if (l!=NULL) delete_list(c,list); + l=alloc_list(c,list); + + c->current_op_buffer=l->first_op_buffer; + c->current_op_buffer_index=0; + + c->compile_flag=1; + c->exec_flag=(mode == GL_COMPILE_AND_EXECUTE); +} + +void glEndList(void) +{ + GLContext *c=gl_get_context(); + GLParam p[1]; + + gl_assert(c->compile_flag == 1); + + /* end of list */ + p[0].op=OP_EndList; + gl_compile_op(c,p); + + c->compile_flag=0; + c->exec_flag=1; +} + +int glIsList(unsigned int list) +{ + GLContext *c=gl_get_context(); + GLList *l; + l=find_list(c,list); + return (l != NULL); +} + +unsigned int glGenLists(int range) +{ + GLContext *c=gl_get_context(); + int count,i,list; + GLList **lists; + + lists=c->shared_state.lists; + count=0; + for(i=0;imatrix_model_projection_updated=(c->matrix_mode<=1); +} + + +void glopMatrixMode(GLContext *c,GLParam *p) +{ + int mode=p[1].i; + switch(mode) { + case GL_MODELVIEW: + c->matrix_mode=0; + break; + case GL_PROJECTION: + c->matrix_mode=1; + break; + case GL_TEXTURE: + c->matrix_mode=2; + break; + default: + gl_assert(0); + } +} + +void glopLoadMatrix(GLContext *c,GLParam *p) +{ + M4 *m; + int i; + + GLParam *q; + + m=c->matrix_stack_ptr[c->matrix_mode]; + q=p+1; + + for(i=0;i<4;i++) { + m->m[0][i]=q[0].f; + m->m[1][i]=q[1].f; + m->m[2][i]=q[2].f; + m->m[3][i]=q[3].f; + q+=4; + } + + gl_matrix_update(c); +} + +void glopLoadIdentity(GLContext *c,GLParam *p) +{ + (void)p; + gl_M4_Id(c->matrix_stack_ptr[c->matrix_mode]); + + gl_matrix_update(c); +} + +void glopMultMatrix(GLContext *c,GLParam *p) +{ + M4 m; + int i; + + GLParam *q; + q=p+1; + + for(i=0;i<4;i++) { + m.m[0][i]=q[0].f; + m.m[1][i]=q[1].f; + m.m[2][i]=q[2].f; + m.m[3][i]=q[3].f; + q+=4; + } + + gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m); + + gl_matrix_update(c); +} + + +void glopPushMatrix(GLContext *c,GLParam *p) +{ + int n=c->matrix_mode; + M4 *m; + (void)p; + + gl_assert( (c->matrix_stack_ptr[n] - c->matrix_stack[n] + 1 ) + < c->matrix_stack_depth_max[n] ); + + m=++c->matrix_stack_ptr[n]; + + gl_M4_Move(&m[0],&m[-1]); + + gl_matrix_update(c); +} + +void glopPopMatrix(GLContext *c,GLParam *p) +{ + int n=c->matrix_mode; + (void)p; + + gl_assert( c->matrix_stack_ptr[n] > c->matrix_stack[n] ); + c->matrix_stack_ptr[n]--; + gl_matrix_update(c); +} + + +void glopRotate(GLContext *c,GLParam *p) +{ + M4 m; + float u[3]; + float angle; + int dir_code; + + angle = p[1].f * M_PI / 180.0; + u[0]=p[2].f; + u[1]=p[3].f; + u[2]=p[4].f; + + /* simple case detection */ + dir_code = ((u[0] != 0)<<2) | ((u[1] != 0)<<1) | (u[2] != 0); + + switch(dir_code) { + case 0: + gl_M4_Id(&m); + break; + case 4: + if (u[0] < 0) angle=-angle; + gl_M4_Rotate(&m,angle,0); + break; + case 2: + if (u[1] < 0) angle=-angle; + gl_M4_Rotate(&m,angle,1); + break; + case 1: + if (u[2] < 0) angle=-angle; + gl_M4_Rotate(&m,angle,2); + break; + default: + { + float cost, sint; + + /* normalize vector */ + float len = u[0]*u[0]+u[1]*u[1]+u[2]*u[2]; + if (len == 0.0f) return; + len = 1.0f / sqrt(len); + u[0] *= len; + u[1] *= len; + u[2] *= len; + + /* store cos and sin values */ + cost=cos(angle); + sint=sin(angle); + + /* fill in the values */ + m.m[3][0]=m.m[3][1]=m.m[3][2]= + m.m[0][3]=m.m[1][3]=m.m[2][3]=0.0f; + m.m[3][3]=1.0f; + + /* do the math */ + m.m[0][0]=u[0]*u[0]+cost*(1-u[0]*u[0]); + m.m[1][0]=u[0]*u[1]*(1-cost)-u[2]*sint; + m.m[2][0]=u[2]*u[0]*(1-cost)+u[1]*sint; + m.m[0][1]=u[0]*u[1]*(1-cost)+u[2]*sint; + m.m[1][1]=u[1]*u[1]+cost*(1-u[1]*u[1]); + m.m[2][1]=u[1]*u[2]*(1-cost)-u[0]*sint; + m.m[0][2]=u[2]*u[0]*(1-cost)-u[1]*sint; + m.m[1][2]=u[1]*u[2]*(1-cost)+u[0]*sint; + m.m[2][2]=u[2]*u[2]+cost*(1-u[2]*u[2]); + } + } + + gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m); + + gl_matrix_update(c); +} + +void glopScale(GLContext *c,GLParam *p) +{ + float *m; + float x=p[1].f,y=p[2].f,z=p[3].f; + + m=&c->matrix_stack_ptr[c->matrix_mode]->m[0][0]; + + m[0] *= x; m[1] *= y; m[2] *= z; + m[4] *= x; m[5] *= y; m[6] *= z; + m[8] *= x; m[9] *= y; m[10] *= z; + m[12] *= x; m[13] *= y; m[14] *= z; + gl_matrix_update(c); +} + +void glopTranslate(GLContext *c,GLParam *p) +{ + float *m; + float x=p[1].f,y=p[2].f,z=p[3].f; + + m=&c->matrix_stack_ptr[c->matrix_mode]->m[0][0]; + + m[3] = m[0] * x + m[1] * y + m[2] * z + m[3]; + m[7] = m[4] * x + m[5] * y + m[6] * z + m[7]; + m[11] = m[8] * x + m[9] * y + m[10] * z + m[11]; + m[15] = m[12] * x + m[13] * y + m[14] * z + m[15]; + + gl_matrix_update(c); +} + + +void glopFrustum(GLContext *c,GLParam *p) +{ + float *r; + M4 m; + float left=p[1].f; + float right=p[2].f; + float bottom=p[3].f; + float top=p[4].f; + float xnear=p[5].f; + float farp=p[6].f; + float x,y,A,B,C,D; + + x = (2.0*xnear) / (right-left); + y = (2.0*xnear) / (top-bottom); + A = (right+left) / (right-left); + B = (top+bottom) / (top-bottom); + C = -(farp+xnear) / ( farp-xnear); + D = -(2.0*farp*xnear) / (farp-xnear); + + r=&m.m[0][0]; + r[0]= x; r[1]=0; r[2]=A; r[3]=0; + r[4]= 0; r[5]=y; r[6]=B; r[7]=0; + r[8]= 0; r[9]=0; r[10]=C; r[11]=D; + r[12]= 0; r[13]=0; r[14]=-1; r[15]=0; + + gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m); + + gl_matrix_update(c); +} + diff --git a/3rdparty/tinygl-0.4-ugfx/src/memory.c b/3rdparty/tinygl-0.4-ugfx/src/memory.c new file mode 100644 index 00000000..e1dc3cbb --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/memory.c @@ -0,0 +1,21 @@ +/* + * Memory allocator for TinyGL + */ +#include "zgl.h" + +/* modify these functions so that they suit your needs */ + +void gl_free(void *p) +{ + free(p); +} + +void *gl_malloc(int size) +{ + return malloc(size); +} + +void *gl_zalloc(int size) +{ + return calloc(1, size); +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/misc.c b/3rdparty/tinygl-0.4-ugfx/src/misc.c new file mode 100644 index 00000000..7dedc75a --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/misc.c @@ -0,0 +1,149 @@ +#include "zgl.h" +#include "msghandling.h" + +void glopViewport(GLContext *c,GLParam *p) +{ + int xsize,ysize,xmin,ymin,xsize_req,ysize_req; + + xmin=p[1].i; + ymin=p[2].i; + xsize=p[3].i; + ysize=p[4].i; + + /* we may need to resize the zbuffer */ + + if (c->viewport.xmin != xmin || + c->viewport.ymin != ymin || + c->viewport.xsize != xsize || + c->viewport.ysize != ysize) { + + xsize_req=xmin+xsize; + ysize_req=ymin+ysize; + + if (c->gl_resize_viewport && + c->gl_resize_viewport(c,&xsize_req,&ysize_req) != 0) { + gl_fatal_error("glViewport: error while resizing display"); + } + + xsize=xsize_req-xmin; + ysize=ysize_req-ymin; + if (xsize <= 0 || ysize <= 0) { + gl_fatal_error("glViewport: size too small"); + } + + tgl_trace("glViewport: %d %d %d %d\n", + xmin, ymin, xsize, ysize); + c->viewport.xmin=xmin; + c->viewport.ymin=ymin; + c->viewport.xsize=xsize; + c->viewport.ysize=ysize; + + c->viewport.updated=1; + } +} + +void glopEnableDisable(GLContext *c,GLParam *p) +{ + int code=p[1].i; + int v=p[2].i; + + switch(code) { + case GL_CULL_FACE: + c->cull_face_enabled=v; + break; + case GL_LIGHTING: + c->lighting_enabled=v; + break; + case GL_COLOR_MATERIAL: + c->color_material_enabled=v; + break; + case GL_TEXTURE_2D: + c->texture_2d_enabled=v; + break; + case GL_NORMALIZE: + c->normalize_enabled=v; + break; + case GL_DEPTH_TEST: + c->depth_test = v; + break; + case GL_POLYGON_OFFSET_FILL: + if (v) c->offset_states |= TGL_OFFSET_FILL; + else c->offset_states &= ~TGL_OFFSET_FILL; + break; + case GL_POLYGON_OFFSET_POINT: + if (v) c->offset_states |= TGL_OFFSET_POINT; + else c->offset_states &= ~TGL_OFFSET_POINT; + break; + case GL_POLYGON_OFFSET_LINE: + if (v) c->offset_states |= TGL_OFFSET_LINE; + else c->offset_states &= ~TGL_OFFSET_LINE; + break; + default: + if (code>=GL_LIGHT0 && codecurrent_shade_model=code; +} + +void glopCullFace(GLContext *c,GLParam *p) +{ + int code=p[1].i; + c->current_cull_face=code; +} + +void glopFrontFace(GLContext *c,GLParam *p) +{ + int code=p[1].i; + c->current_front_face=code; +} + +void glopPolygonMode(GLContext *c,GLParam *p) +{ + int face=p[1].i; + int mode=p[2].i; + + switch(face) { + case GL_BACK: + c->polygon_mode_back=mode; + break; + case GL_FRONT: + c->polygon_mode_front=mode; + break; + case GL_FRONT_AND_BACK: + c->polygon_mode_front=mode; + c->polygon_mode_back=mode; + break; + default: + gl_assert(0); + } +} + +void glopHint(GLContext *c,GLParam *p) +{ + (void)c; + (void)p; +#if 0 + int target=p[1].i; + int mode=p[2].i; + + /* do nothing */ +#endif +} + +void +glopPolygonOffset(GLContext *c, GLParam *p) +{ + c->offset_factor = p[1].f; + c->offset_units = p[2].f; +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/msghandling.c b/3rdparty/tinygl-0.4-ugfx/src/msghandling.c new file mode 100644 index 00000000..c5b10614 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/msghandling.c @@ -0,0 +1,52 @@ +#include +#include + +#define NDEBUG + +#ifdef NDEBUG +#define NO_DEBUG_OUTPUT +#endif + +/* Use this function to output messages when something unexpected + happens (which might be an indication of an error). *Don't* use it + when there's internal errors in the code - these should be handled + by asserts. */ +void +tgl_warning(const char *format, ...) +{ +#ifndef NO_DEBUG_OUTPUT + va_list args; + va_start(args, format); + fprintf(stderr, "*WARNING* "); + vfprintf(stderr, format, args); + va_end(args); +#endif /* !NO_DEBUG_OUTPUT */ +} + +/* This function should be used for debug output only. */ +void +tgl_trace(const char *format, ...) +{ +#ifndef NO_DEBUG_OUTPUT + va_list args; + va_start(args, format); + fprintf(stderr, "*DEBUG* "); + vfprintf(stderr, format, args); + va_end(args); +#endif /* !NO_DEBUG_OUTPUT */ +} + +/* Use this function to output info about things in the code which + should be fixed (missing handling of special cases, important + features not implemented, known bugs/buglets, ...). */ +void +tgl_fixme(const char *format, ...) +{ +#ifndef NO_DEBUG_OUTPUT + va_list args; + va_start(args, format); + fprintf(stderr, "*FIXME* "); + vfprintf(stderr, format, args); + va_end(args); +#endif /* !NO_DEBUG_OUTPUT */ +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/msghandling.h b/3rdparty/tinygl-0.4-ugfx/src/msghandling.h new file mode 100644 index 00000000..ebe4548c --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/msghandling.h @@ -0,0 +1,8 @@ +#ifndef _msghandling_h_ +#define _msghandling_h_ + +extern void tgl_warning(const char *text, ...); +extern void tgl_trace(const char *text, ...); +extern void tgl_fixme(const char *text, ...); + +#endif /* _msghandling_h_ */ diff --git a/3rdparty/tinygl-0.4-ugfx/src/nglx.c b/3rdparty/tinygl-0.4-ugfx/src/nglx.c new file mode 100644 index 00000000..26f356c2 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/nglx.c @@ -0,0 +1,128 @@ +/* simple glx like driver for TinyGL and Nano X */ +#include +#include +#include +#include "zgl.h" + +typedef struct { + GLContext *gl_context; + int xsize,ysize; + GR_DRAW_ID drawable; + GR_GC_ID gc; + int pixtype; /* pixel type in TinyGL */ +} TinyNGLXContext; + +NGLXContext nglXCreateContext(NGLXContext shareList, int flags) +{ + TinyNGLXContext *ctx; + + if (shareList != NULL) { + gl_fatal_error("No sharing available in TinyGL"); + } + ctx=gl_malloc(sizeof(TinyNGLXContext)); + if (!ctx) + return NULL; + ctx->gl_context=NULL; + return (NGLXContext) ctx; +} + +void glXDestroyContext( NGLXContext ctx1 ) +{ + TinyNGLXContext *ctx = (TinyNGLXContext *) ctx1; + if (ctx->gl_context != NULL) { + glClose(); + } + gl_free(ctx); +} + + +/* resize the glx viewport : we try to use the xsize and ysize + given. We return the effective size which is guaranted to be smaller */ + +static int glX_resize_viewport(GLContext *c,int *xsize_ptr,int *ysize_ptr) +{ + TinyNGLXContext *ctx; + int xsize,ysize; + + ctx=(TinyNGLXContext *)c->opaque; + + xsize=*xsize_ptr; + ysize=*ysize_ptr; + + /* we ensure that xsize and ysize are multiples of 2 for the zbuffer. + TODO: find a better solution */ + xsize&=~3; + ysize&=~3; + + if (xsize == 0 || ysize == 0) return -1; + + *xsize_ptr=xsize; + *ysize_ptr=ysize; + + ctx->xsize=xsize; + ctx->ysize=ysize; + + /* resize the Z buffer */ + ZB_resize(c->zb,NULL,xsize,ysize); + return 0; +} + +/* we assume here that drawable is a window */ +int nglXMakeCurrent( NGLXDrawable drawable, + NGLXContext ctx1) +{ + TinyNGLXContext *ctx = (TinyNGLXContext *) ctx1; + int mode, xsize, ysize; + ZBuffer *zb; + GR_WINDOW_INFO win_info; + + if (ctx->gl_context == NULL) { + /* create the TinyGL context */ + GrGetWindowInfo(drawable, &win_info); + + xsize = win_info.width; + ysize = win_info.height; + + /* currently, we only support 16 bit rendering */ + mode = ZB_MODE_5R6G5B; + zb=ZB_open(xsize,ysize,mode,0,NULL,NULL,NULL); + if (zb == NULL) { + fprintf(stderr, "Error while initializing Z buffer\n"); + exit(1); + } + + ctx->pixtype = MWPF_TRUECOLOR565; + + /* create a gc */ + ctx->gc = GrNewGC(); + + /* initialisation of the TinyGL interpreter */ + glInit(zb); + ctx->gl_context=gl_get_context(); + ctx->gl_context->opaque=(void *) ctx; + ctx->gl_context->gl_resize_viewport=glX_resize_viewport; + + /* set the viewport : we force a call to glX_resize_viewport */ + ctx->gl_context->viewport.xsize=-1; + ctx->gl_context->viewport.ysize=-1; + + glViewport(0, 0, xsize, ysize); + } + + return 1; +} + +void nglXSwapBuffers( NGLXDrawable drawable ) +{ + GLContext *gl_context; + TinyNGLXContext *ctx; + + /* retrieve the current NGLXContext */ + gl_context=gl_get_context(); + ctx=(TinyNGLXContext *)gl_context->opaque; + + GrArea(drawable, ctx->gc, 0, 0, ctx->xsize, + ctx->ysize, ctx->gl_context->zb->pbuf, ctx->pixtype); +} + + diff --git a/3rdparty/tinygl-0.4-ugfx/src/opinfo.h b/3rdparty/tinygl-0.4-ugfx/src/opinfo.h new file mode 100644 index 00000000..e57344e8 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/opinfo.h @@ -0,0 +1,71 @@ + + +ADD_OP(Color,7,"%f %f %f %f %d %d %d") +ADD_OP(TexCoord,4,"%f %f %f %f") +ADD_OP(EdgeFlag,1,"%d") +ADD_OP(Normal,3,"%f %f %f") + +ADD_OP(Begin,1,"%C") +ADD_OP(Vertex,4,"%f %f %f %f") +ADD_OP(End,0,"") + +ADD_OP(EnableDisable,2,"%C %d") + +ADD_OP(MatrixMode,1,"%C") +ADD_OP(LoadMatrix,16,"") +ADD_OP(LoadIdentity,0,"") +ADD_OP(MultMatrix,16,"") +ADD_OP(PushMatrix,0,"") +ADD_OP(PopMatrix,0,"") +ADD_OP(Rotate,4,"%f %f %f %f") +ADD_OP(Translate,3,"%f %f %f") +ADD_OP(Scale,3,"%f %f %f") + +ADD_OP(Viewport,4,"%d %d %d %d") +ADD_OP(Frustum,6,"%f %f %f %f %f %f") + +ADD_OP(Material,6,"%C %C %f %f %f %f") +ADD_OP(ColorMaterial,2,"%C %C") +ADD_OP(Light,6,"%C %C %f %f %f %f") +ADD_OP(LightModel,5,"%C %f %f %f %f") + +ADD_OP(Clear,1,"%d") +ADD_OP(ClearColor,4,"%f %f %f %f") +ADD_OP(ClearDepth,1,"%f") + +ADD_OP(InitNames,0,"") +ADD_OP(PushName,1,"%d") +ADD_OP(PopName,0,"") +ADD_OP(LoadName,1,"%d") + +ADD_OP(TexImage2D,9,"%d %d %d %d %d %d %d %d %d") +ADD_OP(BindTexture,2,"%C %d") +ADD_OP(TexEnv,7,"%C %C %C %f %f %f %f") +ADD_OP(TexParameter,7,"%C %C %C %f %f %f %f") +ADD_OP(PixelStore,2,"%C %C") + +ADD_OP(ShadeModel,1,"%C") +ADD_OP(CullFace,1,"%C") +ADD_OP(FrontFace,1,"%C") +ADD_OP(PolygonMode,2,"%C %C") + +ADD_OP(CallList,1,"%d") +ADD_OP(Hint,2,"%C %C") + +/* special opcodes */ +ADD_OP(EndList,0,"") +ADD_OP(NextBuffer,1,"%p") + +/* opengl 1.1 arrays */ +ADD_OP(ArrayElement, 1, "%d") +ADD_OP(EnableClientState, 1, "%C") +ADD_OP(DisableClientState, 1, "%C") +ADD_OP(VertexPointer, 4, "%d %C %d %p") +ADD_OP(ColorPointer, 4, "%d %C %d %p") +ADD_OP(NormalPointer, 3, "%C %d %p") +ADD_OP(TexCoordPointer, 4, "%d %C %d %p") + +/* opengl 1.1 polygon offset */ +ADD_OP(PolygonOffset, 2, "%f %f") + +#undef ADD_OP diff --git a/3rdparty/tinygl-0.4-ugfx/src/oscontext.c b/3rdparty/tinygl-0.4-ugfx/src/oscontext.c new file mode 100644 index 00000000..f91374d3 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/oscontext.c @@ -0,0 +1,83 @@ +#include +#include "zbuffer.h" +#include "zgl.h" +#include +#include + +static int buffercnt = 0; + +ostgl_context * +ostgl_create_context(const int xsize, + const int ysize, + const int depth, + void **framebuffers, + const int numbuffers) +{ + ostgl_context *context; + int i; + ZBuffer *zb; + + gl_assert(depth == 16); /* support for other depths must include bpp + convertion */ + gl_assert(numbuffers >= 1); + + context = gl_malloc(sizeof(ostgl_context)); + gl_assert(context); + context->zbs = gl_malloc(sizeof(void*)*numbuffers); + context->framebuffers = gl_malloc(sizeof(void*)*numbuffers); + + gl_assert(context->zbs != NULL && context->framebuffers != NULL); + + for (i = 0; i < numbuffers; i++) { + context->framebuffers[i] = framebuffers[i]; + zb = ZB_open(xsize, ysize, ZB_MODE_5R6G5B, 0, NULL, NULL, framebuffers[i]); + if (zb == NULL) { + fprintf(stderr, "Error while initializing Z buffer\n"); + exit(1); + } + context->zbs[i] = zb; + } + if (++buffercnt == 1) { + glInit(context->zbs[0]); + } + context->xsize = xsize; + context->ysize = ysize; + context->numbuffers = numbuffers; + return context; +} + +void +ostgl_delete_context(ostgl_context *context) +{ + int i; + for (i = 0; i < context->numbuffers; i++) { + ZB_close(context->zbs[i]); + } + gl_free(context->zbs); + gl_free(context->framebuffers); + gl_free(context); + + if (--buffercnt == 0) { + glClose(); + } +} + +void +ostgl_make_current(ostgl_context *oscontext, const int idx) +{ + GLContext *context = gl_get_context(); + gl_assert(idx < oscontext->numbuffers); + context->zb = oscontext->zbs[idx]; +} + +void +ostgl_resize(ostgl_context *context, + const int xsize, + const int ysize, + void **framebuffers) +{ + int i; + for (i = 0; i < context->numbuffers; i++) { + ZB_resize(context->zbs[i], framebuffers[i], xsize, ysize); + } +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/select.c b/3rdparty/tinygl-0.4-ugfx/src/select.c new file mode 100644 index 00000000..46134dbc --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/select.c @@ -0,0 +1,116 @@ +#include "zgl.h" + +int glRenderMode(int mode) +{ + GLContext *c=gl_get_context(); + int result=0; + + switch(c->render_mode) { + case GL_RENDER: + break; + case GL_SELECT: + if (c->select_overflow) { + result=-c->select_hits; + } else { + result=c->select_hits; + } + c->select_overflow=0; + c->select_ptr=c->select_buffer; + c->name_stack_size=0; + break; + default: + gl_assert(0); + } + switch(mode) { + case GL_RENDER: + c->render_mode=GL_RENDER; + break; + case GL_SELECT: + c->render_mode=GL_SELECT; + gl_assert( c->select_buffer != NULL); + c->select_ptr=c->select_buffer; + c->select_hits=0; + c->select_overflow=0; + c->select_hit=NULL; + break; + default: + gl_assert(0); + } + return result; +} + +void glSelectBuffer(int size,unsigned int *buf) +{ + GLContext *c=gl_get_context(); + + gl_assert(c->render_mode != GL_SELECT); + + c->select_buffer=buf; + c->select_size=size; +} + + +void glopInitNames(GLContext *c,GLParam *p) +{ + (void)p; + if (c->render_mode == GL_SELECT) { + c->name_stack_size=0; + c->select_hit=NULL; + } +} + +void glopPushName(GLContext *c,GLParam *p) +{ + if (c->render_mode == GL_SELECT) { + gl_assert(c->name_stack_sizename_stack[c->name_stack_size++]=p[1].i; + c->select_hit=NULL; + } +} + +void glopPopName(GLContext *c,GLParam *p) +{ + (void)p; + if (c->render_mode == GL_SELECT) { + gl_assert(c->name_stack_size>0); + c->name_stack_size--; + c->select_hit=NULL; + } +} + +void glopLoadName(GLContext *c,GLParam *p) +{ + if (c->render_mode == GL_SELECT) { + gl_assert(c->name_stack_size>0); + c->name_stack[c->name_stack_size-1]=p[1].i; + c->select_hit=NULL; + } +} + +void gl_add_select(GLContext *c,unsigned int zmin,unsigned int zmax) +{ + unsigned int *ptr; + int n,i; + + if (!c->select_overflow) { + if (c->select_hit==NULL) { + n=c->name_stack_size; + if ((c->select_ptr-c->select_buffer+3+n) > + c->select_size) { + c->select_overflow=1; + } else { + ptr=c->select_ptr; + c->select_hit=ptr; + *ptr++=c->name_stack_size; + *ptr++=zmin; + *ptr++=zmax; + for(i=0;iname_stack[i]; + c->select_ptr=ptr; + c->select_hits++; + } + } else { + if (zminselect_hit[1]) c->select_hit[1]=zmin; + if (zmax>c->select_hit[2]) c->select_hit[2]=zmax; + } + } +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/specbuf.c b/3rdparty/tinygl-0.4-ugfx/src/specbuf.c new file mode 100644 index 00000000..7cbfb057 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/specbuf.c @@ -0,0 +1,52 @@ +#include "zgl.h" +#include "msghandling.h" +#include +#include + +static void calc_buf(GLSpecBuf *buf, const float shininess) +{ + int i; + float val, inc; + val = 0.0f; + inc = 1.0f/SPECULAR_BUFFER_SIZE; + for (i = 0; i <= SPECULAR_BUFFER_SIZE; i++) { + buf->buf[i] = pow(val, shininess); + val += inc; + } +} + +GLSpecBuf * +specbuf_get_buffer(GLContext *c, const int shininess_i, + const float shininess) +{ + GLSpecBuf *found, *oldest; + found = oldest = c->specbuf_first; + while (found && found->shininess_i != shininess_i) { + if (found->last_used < oldest->last_used) { + oldest = found; + } + found = found->next; + } + if (found) { /* hey, found one! */ + found->last_used = c->specbuf_used_counter++; + return found; + } + if (oldest == NULL || c->specbuf_num_buffers < MAX_SPECULAR_BUFFERS) { + /* create new buffer */ + GLSpecBuf *buf = gl_malloc(sizeof(GLSpecBuf)); + if (!buf) gl_fatal_error("could not allocate specular buffer"); + c->specbuf_num_buffers++; + buf->next = c->specbuf_first; + c->specbuf_first = buf; + buf->last_used = c->specbuf_used_counter++; + buf->shininess_i = shininess_i; + calc_buf(buf, shininess); + return buf; + } + /* overwrite the lru buffer */ + /*tgl_trace("overwriting spec buffer :(\n");*/ + oldest->shininess_i = shininess_i; + oldest->last_used = c->specbuf_used_counter++; + calc_buf(oldest, shininess); + return oldest; +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/specbuf.h b/3rdparty/tinygl-0.4-ugfx/src/specbuf.h new file mode 100644 index 00000000..ae5da3f8 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/specbuf.h @@ -0,0 +1,22 @@ +#ifndef _tgl_specbuf_h_ +#define _tgl_specbuf_h_ + +/* Max # of specular light pow buffers */ +#define MAX_SPECULAR_BUFFERS 8 +/* # of entries in specular buffer */ +#define SPECULAR_BUFFER_SIZE 1024 +/* specular buffer granularity */ +#define SPECULAR_BUFFER_RESOLUTION 1024 + +typedef struct GLSpecBuf { + int shininess_i; + int last_used; + float buf[SPECULAR_BUFFER_SIZE+1]; + struct GLSpecBuf *next; +} GLSpecBuf; + +GLSpecBuf *specbuf_get_buffer(GLContext *c, const int shininess_i, + const float shininess); +void specbuf_cleanup(GLContext *c); /* free all memory used */ + +#endif /* _tgl_specbuf_h_ */ \ No newline at end of file diff --git a/3rdparty/tinygl-0.4-ugfx/src/texture.c b/3rdparty/tinygl-0.4-ugfx/src/texture.c new file mode 100644 index 00000000..abd88bd9 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/texture.c @@ -0,0 +1,232 @@ +/* + * Texture Manager + */ + +#include "zgl.h" + +static GLTexture *find_texture(GLContext *c,int h) +{ + GLTexture *t; + + t=c->shared_state.texture_hash_table[h % TEXTURE_HASH_TABLE_SIZE]; + while (t!=NULL) { + if (t->handle == h) return t; + t=t->next; + } + return NULL; +} + +static void free_texture(GLContext *c,int h) +{ + GLTexture *t,**ht; + GLImage *im; + int i; + + t=find_texture(c,h); + if (t->prev==NULL) { + ht=&c->shared_state.texture_hash_table + [t->handle % TEXTURE_HASH_TABLE_SIZE]; + *ht=t->next; + } else { + t->prev->next=t->next; + } + if (t->next!=NULL) t->next->prev=t->prev; + + for(i=0;iimages[i]; + if (im->pixmap != NULL) gl_free(im->pixmap); + } + + gl_free(t); +} + +GLTexture *alloc_texture(GLContext *c,int h) +{ + GLTexture *t,**ht; + + t=gl_zalloc(sizeof(GLTexture)); + + ht=&c->shared_state.texture_hash_table[h % TEXTURE_HASH_TABLE_SIZE]; + + t->next=*ht; + t->prev=NULL; + if (t->next != NULL) t->next->prev=t; + *ht=t; + + t->handle=h; + + return t; +} + + +void glInitTextures(GLContext *c) +{ + /* textures */ + + c->texture_2d_enabled=0; + c->current_texture=find_texture(c,0); +} + +void glGenTextures(int n, unsigned int *textures) +{ + GLContext *c=gl_get_context(); + int max,i; + GLTexture *t; + + max=0; + for(i=0;ishared_state.texture_hash_table[i]; + while (t!=NULL) { + if (t->handle>max) max=t->handle; + t=t->next; + } + + } + for(i=0;icurrent_texture) { + glBindTexture(GL_TEXTURE_2D,0); + } + free_texture(c,textures[i]); + } + } +} + + +void glopBindTexture(GLContext *c,GLParam *p) +{ + int target=p[1].i; + int texture=p[2].i; + GLTexture *t; + + gl_assert(target == GL_TEXTURE_2D && texture >= 0); + + t=find_texture(c,texture); + if (t==NULL) { + t=alloc_texture(c,texture); + } + c->current_texture=t; +} + +void glopTexImage2D(GLContext *c,GLParam *p) +{ + int target=p[1].i; + int level=p[2].i; + int components=p[3].i; + int width=p[4].i; + int height=p[5].i; + int border=p[6].i; + int format=p[7].i; + int type=p[8].i; + void *pixels=p[9].p; + GLImage *im; + unsigned char *pixels1; + int do_free; + + if (!(target == GL_TEXTURE_2D && level == 0 && components == 3 && + border == 0 && format == GL_RGB && + type == GL_UNSIGNED_BYTE)) { + gl_fatal_error("glTexImage2D: combinaison of parameters not handled"); + } + + do_free=0; + if (width != 256 || height != 256) { + pixels1 = gl_malloc(256 * 256 * 3); + /* no interpolation is done here to respect the original image aliasing ! */ + gl_resizeImageNoInterpolate(pixels1,256,256,pixels,width,height); + do_free=1; + width=256; + height=256; + } else { + pixels1=pixels; + } + + im=&c->current_texture->images[level]; + im->xsize=width; + im->ysize=height; + if (im->pixmap!=NULL) gl_free(im->pixmap); +#if TGL_FEATURE_RENDER_BITS == 24 + im->pixmap=gl_malloc(width*height*3); + if(im->pixmap) { + memcpy(im->pixmap,pixels1,width*height*3); + } +#elif TGL_FEATURE_RENDER_BITS == 32 + im->pixmap=gl_malloc(width*height*4); + if(im->pixmap) { + gl_convertRGB_to_8A8R8G8B(im->pixmap,pixels1,width,height); + } +#elif TGL_FEATURE_RENDER_BITS == 16 + im->pixmap=gl_malloc(width*height*2); + if(im->pixmap) { + gl_convertRGB_to_5R6G5B(im->pixmap,pixels1,width,height); + } +#else +#error TODO +#endif + if (do_free) gl_free(pixels1); +} + + +/* TODO: not all tests are done */ +void glopTexEnv(GLContext *c,GLParam *p) +{ + int target=p[1].i; + int pname=p[2].i; + int param=p[3].i; + (void)c; + + if (target != GL_TEXTURE_ENV) { + error: + gl_fatal_error("glTexParameter: unsupported option"); + } + + if (pname != GL_TEXTURE_ENV_MODE) goto error; + + if (param != GL_DECAL) goto error; +} + +/* TODO: not all tests are done */ +void glopTexParameter(GLContext *c,GLParam *p) +{ + int target=p[1].i; + int pname=p[2].i; + int param=p[3].i; + (void)c; + + if (target != GL_TEXTURE_2D) { + error: + gl_fatal_error("glTexParameter: unsupported option"); + } + + switch(pname) { + case GL_TEXTURE_WRAP_S: + case GL_TEXTURE_WRAP_T: + if (param != GL_REPEAT) goto error; + break; + } +} + +void glopPixelStore(GLContext *c,GLParam *p) +{ + int pname=p[1].i; + int param=p[2].i; + (void)c; + + if (pname != GL_UNPACK_ALIGNMENT || + param != 1) { + gl_fatal_error("glPixelStore: unsupported option"); + } +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/vertex.c b/3rdparty/tinygl-0.4-ugfx/src/vertex.c new file mode 100644 index 00000000..6532c433 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/vertex.c @@ -0,0 +1,365 @@ +#include "zgl.h" + +void glopNormal(GLContext * c, GLParam * p) +{ + V3 v; + + v.X = p[1].f; + v.Y = p[2].f; + v.Z = p[3].f; + + c->current_normal.X = v.X; + c->current_normal.Y = v.Y; + c->current_normal.Z = v.Z; + c->current_normal.W = 0; +} + +void glopTexCoord(GLContext * c, GLParam * p) +{ + c->current_tex_coord.X = p[1].f; + c->current_tex_coord.Y = p[2].f; + c->current_tex_coord.Z = p[3].f; + c->current_tex_coord.W = p[4].f; +} + +void glopEdgeFlag(GLContext * c, GLParam * p) +{ + c->current_edge_flag = p[1].i; +} + +void glopColor(GLContext * c, GLParam * p) +{ + + c->current_color.X = p[1].f; + c->current_color.Y = p[2].f; + c->current_color.Z = p[3].f; + c->current_color.W = p[4].f; + c->longcurrent_color[0] = p[5].ui; + c->longcurrent_color[1] = p[6].ui; + c->longcurrent_color[2] = p[7].ui; + + if (c->color_material_enabled) { + GLParam q[7]; + q[0].op = OP_Material; + q[1].i = c->current_color_material_mode; + q[2].i = c->current_color_material_type; + q[3].f = p[1].f; + q[4].f = p[2].f; + q[5].f = p[3].f; + q[6].f = p[4].f; + glopMaterial(c, q); + } +} + + +void gl_eval_viewport(GLContext * c) +{ + GLViewport *v; + float zsize = (1 << (ZB_Z_BITS + ZB_POINT_Z_FRAC_BITS)); + + v = &c->viewport; + + v->trans.X = ((v->xsize - 0.5) / 2.0) + v->xmin; + v->trans.Y = ((v->ysize - 0.5) / 2.0) + v->ymin; + v->trans.Z = ((zsize - 0.5) / 2.0) + ((1 << ZB_POINT_Z_FRAC_BITS)) / 2; + + v->scale.X = (v->xsize - 0.5) / 2.0; + v->scale.Y = -(v->ysize - 0.5) / 2.0; + v->scale.Z = -((zsize - 0.5) / 2.0); +} + +void glopBegin(GLContext * c, GLParam * p) +{ + int type; + M4 tmp; + + gl_assert(c->in_begin == 0); + + type = p[1].i; + c->begin_type = type; + c->in_begin = 1; + c->vertex_n = 0; + c->vertex_cnt = 0; + + if (c->matrix_model_projection_updated) { + + if (c->lighting_enabled) { + /* precompute inverse modelview */ + gl_M4_Inv(&tmp, c->matrix_stack_ptr[0]); + gl_M4_Transpose(&c->matrix_model_view_inv, &tmp); + } else { + float *m = &c->matrix_model_projection.m[0][0]; + /* precompute projection matrix */ + gl_M4_Mul(&c->matrix_model_projection, + c->matrix_stack_ptr[1], + c->matrix_stack_ptr[0]); + /* test to accelerate computation */ + c->matrix_model_projection_no_w_transform = 0; + if (m[12] == 0.0 && m[13] == 0.0 && m[14] == 0.0) + c->matrix_model_projection_no_w_transform = 1; + } + + /* test if the texture matrix is not Identity */ + c->apply_texture_matrix = !gl_M4_IsId(c->matrix_stack_ptr[2]); + + c->matrix_model_projection_updated = 0; + } + /* viewport */ + if (c->viewport.updated) { + gl_eval_viewport(c); + c->viewport.updated = 0; + } + /* triangle drawing functions */ + if (c->render_mode == GL_SELECT) { + c->draw_triangle_front = gl_draw_triangle_select; + c->draw_triangle_back = gl_draw_triangle_select; + } else { + switch (c->polygon_mode_front) { + case GL_POINT: + c->draw_triangle_front = gl_draw_triangle_point; + break; + case GL_LINE: + c->draw_triangle_front = gl_draw_triangle_line; + break; + default: + c->draw_triangle_front = gl_draw_triangle_fill; + break; + } + + switch (c->polygon_mode_back) { + case GL_POINT: + c->draw_triangle_back = gl_draw_triangle_point; + break; + case GL_LINE: + c->draw_triangle_back = gl_draw_triangle_line; + break; + default: + c->draw_triangle_back = gl_draw_triangle_fill; + break; + } + } +} + +/* coords, tranformation , clip code and projection */ +/* TODO : handle all cases */ +static inline void gl_vertex_transform(GLContext * c, GLVertex * v) +{ + float *m; + V4 *n; + + if (c->lighting_enabled) { + /* eye coordinates needed for lighting */ + + m = &c->matrix_stack_ptr[0]->m[0][0]; + v->ec.X = (v->coord.X * m[0] + v->coord.Y * m[1] + + v->coord.Z * m[2] + m[3]); + v->ec.Y = (v->coord.X * m[4] + v->coord.Y * m[5] + + v->coord.Z * m[6] + m[7]); + v->ec.Z = (v->coord.X * m[8] + v->coord.Y * m[9] + + v->coord.Z * m[10] + m[11]); + v->ec.W = (v->coord.X * m[12] + v->coord.Y * m[13] + + v->coord.Z * m[14] + m[15]); + + /* projection coordinates */ + m = &c->matrix_stack_ptr[1]->m[0][0]; + v->pc.X = (v->ec.X * m[0] + v->ec.Y * m[1] + + v->ec.Z * m[2] + v->ec.W * m[3]); + v->pc.Y = (v->ec.X * m[4] + v->ec.Y * m[5] + + v->ec.Z * m[6] + v->ec.W * m[7]); + v->pc.Z = (v->ec.X * m[8] + v->ec.Y * m[9] + + v->ec.Z * m[10] + v->ec.W * m[11]); + v->pc.W = (v->ec.X * m[12] + v->ec.Y * m[13] + + v->ec.Z * m[14] + v->ec.W * m[15]); + + m = &c->matrix_model_view_inv.m[0][0]; + n = &c->current_normal; + + v->normal.X = (n->X * m[0] + n->Y * m[1] + n->Z * m[2]); + v->normal.Y = (n->X * m[4] + n->Y * m[5] + n->Z * m[6]); + v->normal.Z = (n->X * m[8] + n->Y * m[9] + n->Z * m[10]); + + if (c->normalize_enabled) { + gl_V3_Norm(&v->normal); + } + } else { + /* no eye coordinates needed, no normal */ + /* NOTE: W = 1 is assumed */ + m = &c->matrix_model_projection.m[0][0]; + + v->pc.X = (v->coord.X * m[0] + v->coord.Y * m[1] + + v->coord.Z * m[2] + m[3]); + v->pc.Y = (v->coord.X * m[4] + v->coord.Y * m[5] + + v->coord.Z * m[6] + m[7]); + v->pc.Z = (v->coord.X * m[8] + v->coord.Y * m[9] + + v->coord.Z * m[10] + m[11]); + if (c->matrix_model_projection_no_w_transform) { + v->pc.W = m[15]; + } else { + v->pc.W = (v->coord.X * m[12] + v->coord.Y * m[13] + + v->coord.Z * m[14] + m[15]); + } + } + + v->clip_code = gl_clipcode(v->pc.X, v->pc.Y, v->pc.Z, v->pc.W); +} + +void glopVertex(GLContext * c, GLParam * p) +{ + GLVertex *v; + int n, i, cnt; + + gl_assert(c->in_begin != 0); + + n = c->vertex_n; + cnt = c->vertex_cnt; + cnt++; + c->vertex_cnt = cnt; + + /* quick fix to avoid crashes on large polygons */ + if (n >= c->vertex_max) { + GLVertex *newarray; + c->vertex_max <<= 1; /* just double size */ + newarray = gl_malloc(sizeof(GLVertex) * c->vertex_max); + if (!newarray) { + gl_fatal_error("unable to allocate GLVertex array.\n"); + } + memcpy(newarray, c->vertex, n * sizeof(GLVertex)); + gl_free(c->vertex); + c->vertex = newarray; + } + /* new vertex entry */ + v = &c->vertex[n]; + n++; + + v->coord.X = p[1].f; + v->coord.Y = p[2].f; + v->coord.Z = p[3].f; + v->coord.W = p[4].f; + + gl_vertex_transform(c, v); + + /* color */ + + if (c->lighting_enabled) { + gl_shade_vertex(c, v); + } else { + v->color = c->current_color; + } + + /* tex coords */ + + if (c->texture_2d_enabled) { + if (c->apply_texture_matrix) { + gl_M4_MulV4(&v->tex_coord, c->matrix_stack_ptr[2], &c->current_tex_coord); + } else { + v->tex_coord = c->current_tex_coord; + } + } + /* precompute the mapping to the viewport */ + if (v->clip_code == 0) + gl_transform_to_viewport(c, v); + + /* edge flag */ + + v->edge_flag = c->current_edge_flag; + + switch (c->begin_type) { + case GL_POINTS: + gl_draw_point(c, &c->vertex[0]); + n = 0; + break; + + case GL_LINES: + if (n == 2) { + gl_draw_line(c, &c->vertex[0], &c->vertex[1]); + n = 0; + } + break; + case GL_LINE_STRIP: + case GL_LINE_LOOP: + if (n == 1) { + c->vertex[2] = c->vertex[0]; + } else if (n == 2) { + gl_draw_line(c, &c->vertex[0], &c->vertex[1]); + c->vertex[0] = c->vertex[1]; + n = 1; + } + break; + + case GL_TRIANGLES: + if (n == 3) { + gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]); + n = 0; + } + break; + case GL_TRIANGLE_STRIP: + if (cnt >= 3) { + if (n == 3) + n = 0; + /* needed to respect triangle orientation */ + switch(cnt & 1) { + case 0: + gl_draw_triangle(c,&c->vertex[2],&c->vertex[1],&c->vertex[0]); + break; + default: + case 1: + gl_draw_triangle(c,&c->vertex[0],&c->vertex[1],&c->vertex[2]); + break; + } + } + break; + case GL_TRIANGLE_FAN: + if (n == 3) { + gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]); + c->vertex[1] = c->vertex[2]; + n = 2; + } + break; + + case GL_QUADS: + if (n == 4) { + c->vertex[2].edge_flag = 0; + gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]); + c->vertex[2].edge_flag = 1; + c->vertex[0].edge_flag = 0; + gl_draw_triangle(c, &c->vertex[0], &c->vertex[2], &c->vertex[3]); + n = 0; + } + break; + + case GL_QUAD_STRIP: + if (n == 4) { + gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]); + gl_draw_triangle(c, &c->vertex[1], &c->vertex[3], &c->vertex[2]); + for (i = 0; i < 2; i++) + c->vertex[i] = c->vertex[i + 2]; + n = 2; + } + break; + case GL_POLYGON: + break; + default: + gl_fatal_error("glBegin: type %x not handled\n", c->begin_type); + } + + c->vertex_n = n; +} + +void glopEnd(GLContext * c, GLParam * param) +{ + (void) param; + gl_assert(c->in_begin == 1); + + if (c->begin_type == GL_LINE_LOOP) { + if (c->vertex_cnt >= 3) { + gl_draw_line(c, &c->vertex[0], &c->vertex[2]); + } + } else if (c->begin_type == GL_POLYGON) { + int i = c->vertex_cnt; + while (i >= 3) { + i--; + gl_draw_triangle(c, &c->vertex[i], &c->vertex[0], &c->vertex[i - 1]); + } + } + c->in_begin = 0; +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/zbuffer.c b/3rdparty/tinygl-0.4-ugfx/src/zbuffer.c new file mode 100644 index 00000000..a62baa04 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/zbuffer.c @@ -0,0 +1,517 @@ +/* + + * Z buffer: 16 bits Z / 16 bits color + * + */ +#include +#include +#include +#include "zbuffer.h" + +ZBuffer *ZB_open(int xsize, int ysize, int mode, + int nb_colors, + unsigned char *color_indexes, + int *color_table, + void *frame_buffer) +{ + ZBuffer *zb; + int size; + + zb = gl_malloc(sizeof(ZBuffer)); + if (zb == NULL) + return NULL; + + zb->xsize = xsize; + zb->ysize = ysize; + zb->mode = mode; + zb->linesize = (xsize * PSZB + 3) & ~3; + + switch (mode) { +#ifdef TGL_FEATURE_8_BITS + case ZB_MODE_INDEX: + ZB_initDither(zb, nb_colors, color_indexes, color_table); + break; +#endif +#ifdef TGL_FEATURE_32_BITS + case ZB_MODE_RGBA: +#endif +#ifdef TGL_FEATURE_24_BITS + case ZB_MODE_RGB24: +#endif + case ZB_MODE_5R6G5B: + zb->nb_colors = 0; + break; + default: + goto error; + } + + size = zb->xsize * zb->ysize * sizeof(unsigned short); + + zb->zbuf = gl_malloc(size); + if (zb->zbuf == NULL) + goto error; + + if (frame_buffer == NULL) { + zb->pbuf = gl_malloc(zb->ysize * zb->linesize); + if (zb->pbuf == NULL) { + gl_free(zb->zbuf); + goto error; + } + zb->frame_buffer_allocated = 1; + } else { + zb->frame_buffer_allocated = 0; + zb->pbuf = frame_buffer; + } + + zb->current_texture = NULL; + + return zb; + error: + gl_free(zb); + return NULL; +} + +void ZB_close(ZBuffer * zb) +{ +#ifdef TGL_FEATURE_8_BITS + if (zb->mode == ZB_MODE_INDEX) + ZB_closeDither(zb); +#endif + + if (zb->frame_buffer_allocated) + gl_free(zb->pbuf); + + gl_free(zb->zbuf); + gl_free(zb); +} + +void ZB_resize(ZBuffer * zb, void *frame_buffer, int xsize, int ysize) +{ + int size; + + /* xsize must be a multiple of 4 */ + xsize = xsize & ~3; + + zb->xsize = xsize; + zb->ysize = ysize; + zb->linesize = (xsize * PSZB + 3) & ~3; + + size = zb->xsize * zb->ysize * sizeof(unsigned short); + + gl_free(zb->zbuf); + zb->zbuf = gl_malloc(size); + + if (zb->frame_buffer_allocated) + gl_free(zb->pbuf); + + if (frame_buffer == NULL) { + zb->pbuf = gl_malloc(zb->ysize * zb->linesize); + zb->frame_buffer_allocated = 1; + } else { + zb->pbuf = frame_buffer; + zb->frame_buffer_allocated = 0; + } +} + +static void ZB_copyBuffer(ZBuffer * zb, + void *buf, + int linesize) +{ + unsigned char *p1; + PIXEL *q; + int y, n; + + q = zb->pbuf; + p1 = buf; + n = zb->xsize * PSZB; + for (y = 0; y < zb->ysize; y++) { + memcpy(p1, q, n); + p1 += linesize; + q = (PIXEL *) ((char *) q + zb->linesize); + } +} + +#if TGL_FEATURE_RENDER_BITS == 16 + +/* 32 bpp copy */ + +#ifdef TGL_FEATURE_32_BITS + +#define RGB16_TO_RGB32(p0,p1,v)\ +{\ + unsigned int g,b,gb;\ + g = (v & 0x07E007E0) << 5;\ + b = (v & 0x001F001F) << 3;\ + gb = g | b;\ + p0 = (gb & 0x0000FFFF) | ((v & 0x0000F800) << 8);\ + p1 = (gb >> 16) | ((v & 0xF8000000) >> 8);\ +} + +static void ZB_copyFrameBufferRGB32(ZBuffer * zb, + void *buf, + int linesize) +{ + unsigned short *q; + unsigned int *p, *p1, v, w0, w1; + int y, n; + + q = zb->pbuf; + p1 = (unsigned int *) buf; + + for (y = 0; y < zb->ysize; y++) { + p = p1; + n = zb->xsize >> 2; + do { + v = *(unsigned int *) q; +#if BYTE_ORDER == BIG_ENDIAN + RGB16_TO_RGB32(w1, w0, v); +#else + RGB16_TO_RGB32(w0, w1, v); +#endif + p[0] = w0; + p[1] = w1; + + v = *(unsigned int *) (q + 2); +#if BYTE_ORDER == BIG_ENDIAN + RGB16_TO_RGB32(w1, w0, v); +#else + RGB16_TO_RGB32(w0, w1, v); +#endif + p[2] = w0; + p[3] = w1; + + q += 4; + p += 4; + } while (--n > 0); + + p1 += linesize; + } +} + +#endif + +/* 24 bit packed pixel handling */ + +#ifdef TGL_FEATURE_24_BITS + +/* order: RGBR GBRG BRGB */ + +/* XXX: packed pixel 24 bit support not tested */ +/* XXX: big endian case not optimised */ + +#if BYTE_ORDER == BIG_ENDIAN + +#define RGB16_TO_RGB24(p0,p1,p2,v1,v2)\ +{\ + unsigned int r1,g1,b1,gb1,g2,b2,gb2;\ + v1 = (v1 << 16) | (v1 >> 16);\ + v2 = (v2 << 16) | (v2 >> 16);\ + r1 = (v1 & 0xF800F800);\ + g1 = (v1 & 0x07E007E0) << 5;\ + b1 = (v1 & 0x001F001F) << 3;\ + gb1 = g1 | b1;\ + p0 = ((gb1 & 0x0000FFFF) << 8) | (r1 << 16) | (r1 >> 24);\ + g2 = (v2 & 0x07E007E0) << 5;\ + b2 = (v2 & 0x001F001F) << 3;\ + gb2 = g2 | b2;\ + p1 = (gb1 & 0xFFFF0000) | (v2 & 0xF800) | ((gb2 >> 8) & 0xff);\ + p2 = (gb2 << 24) | ((v2 & 0xF8000000) >> 8) | (gb2 >> 16);\ +} + +#else + +#define RGB16_TO_RGB24(p0,p1,p2,v1,v2)\ +{\ + unsigned int r1,g1,b1,gb1,g2,b2,gb2;\ + r1 = (v1 & 0xF800F800);\ + g1 = (v1 & 0x07E007E0) << 5;\ + b1 = (v1 & 0x001F001F) << 3;\ + gb1 = g1 | b1;\ + p0 = ((gb1 & 0x0000FFFF) << 8) | (r1 << 16) | (r1 >> 24);\ + g2 = (v2 & 0x07E007E0) << 5;\ + b2 = (v2 & 0x001F001F) << 3;\ + gb2 = g2 | b2;\ + p1 = (gb1 & 0xFFFF0000) | (v2 & 0xF800) | ((gb2 >> 8) & 0xff);\ + p2 = (gb2 << 24) | ((v2 & 0xF8000000) >> 8) | (gb2 >> 16);\ +} + +#endif + +static void ZB_copyFrameBufferRGB24(ZBuffer * zb, + void *buf, + int linesize) +{ + unsigned short *q; + unsigned int *p, *p1, w0, w1, w2, v0, v1; + int y, n; + + q = zb->pbuf; + p1 = (unsigned int *) buf; + linesize = linesize * 3; + + for (y = 0; y < zb->ysize; y++) { + p = p1; + n = zb->xsize >> 2; + do { + v0 = *(unsigned int *) q; + v1 = *(unsigned int *) (q + 2); + RGB16_TO_RGB24(w0, w1, w2, v0, v1); + p[0] = w0; + p[1] = w1; + p[2] = w2; + + q += 4; + p += 3; + } while (--n > 0); + + p1 = (unsigned int *)(((char *)p1) + linesize); + } +} + +#endif + +void ZB_copyFrameBuffer(ZBuffer * zb, void *buf, + int linesize) +{ + switch (zb->mode) { +#ifdef TGL_FEATURE_8_BITS + case ZB_MODE_INDEX: + ZB_ditherFrameBuffer(zb, buf, linesize >> 1); + break; +#endif +#ifdef TGL_FEATURE_16_BITS + case ZB_MODE_5R6G5B: + ZB_copyBuffer(zb, buf, linesize); + break; +#endif +#ifdef TGL_FEATURE_32_BITS + case ZB_MODE_RGBA: + ZB_copyFrameBufferRGB32(zb, buf, linesize >> 1); + break; +#endif +#ifdef TGL_FEATURE_24_BITS + case ZB_MODE_RGB24: + ZB_copyFrameBufferRGB24(zb, buf, linesize >> 1); + break; +#endif + default: + gl_assert(0); + } +} + +#endif /* TGL_FEATURE_RENDER_BITS == 16 */ + +#if TGL_FEATURE_RENDER_BITS == 24 + +#define RGB24_TO_RGB16(r, g, b) \ + ((((r) >> 3) << 11) | (((g) >> 2) << 5) | ((b) >> 3)) + +/* XXX: not optimized */ +static void ZB_copyFrameBuffer5R6G5B(ZBuffer * zb, + void *buf, int linesize) +{ + PIXEL *q; + unsigned short *p, *p1; + int y, n; + + q = zb->pbuf; + p1 = (unsigned short *) buf; + + for (y = 0; y < zb->ysize; y++) { + p = p1; + n = zb->xsize >> 2; + do { + p[0] = RGB24_TO_RGB16(q[0], q[1], q[2]); + p[1] = RGB24_TO_RGB16(q[3], q[4], q[5]); + p[2] = RGB24_TO_RGB16(q[6], q[7], q[8]); + p[3] = RGB24_TO_RGB16(q[9], q[10], q[11]); + q = (PIXEL *)((char *)q + 4 * PSZB); + p += 4; + } while (--n > 0); + p1 = (unsigned short *)((char *)p1 + linesize); + } +} + +void ZB_copyFrameBuffer(ZBuffer * zb, void *buf, + int linesize) +{ + switch (zb->mode) { +#ifdef TGL_FEATURE_16_BITS + case ZB_MODE_5R6G5B: + ZB_copyFrameBuffer5R6G5B(zb, buf, linesize); + break; +#endif +#ifdef TGL_FEATURE_24_BITS + case ZB_MODE_RGB24: + ZB_copyBuffer(zb, buf, linesize); + break; +#endif + default: + gl_assert(0); + } +} + +#endif /* TGL_FEATURE_RENDER_BITS == 24 */ + +#if TGL_FEATURE_RENDER_BITS == 32 + +#define RGB32_TO_RGB16(v) \ + (((v >> 8) & 0xf800) | (((v) >> 5) & 0x07e0) | (((v) & 0xff) >> 3)) + +/* XXX: not optimized */ +static void ZB_copyFrameBuffer5R6G5B(ZBuffer * zb, + void *buf, int linesize) +{ + PIXEL *q; + unsigned short *p, *p1; + int y, n; + + q = zb->pbuf; + p1 = (unsigned short *) buf; + + for (y = 0; y < zb->ysize; y++) { + p = p1; + n = zb->xsize >> 2; + do { + p[0] = RGB32_TO_RGB16(q[0]); + p[1] = RGB32_TO_RGB16(q[1]); + p[2] = RGB32_TO_RGB16(q[2]); + p[3] = RGB32_TO_RGB16(q[3]); + q += 4; + p += 4; + } while (--n > 0); + p1 = (unsigned short *)((char *)p1 + linesize); + } +} + +void ZB_copyFrameBuffer(ZBuffer * zb, void *buf, + int linesize) +{ + switch (zb->mode) { +#ifdef TGL_FEATURE_16_BITS + case ZB_MODE_5R6G5B: + ZB_copyFrameBuffer5R6G5B(zb, buf, linesize); + break; +#endif +#ifdef TGL_FEATURE_32_BITS + case ZB_MODE_RGBA: + ZB_copyBuffer(zb, buf, linesize); + break; +#endif + default: + gl_assert(0); + } +} + +#endif /* TGL_FEATURE_RENDER_BITS == 32 */ + + +/* + * adr must be aligned on an 'int' + */ +void memset_s(void *adr, int val, int count) +{ + int i, n, v; + unsigned int *p; + unsigned short *q; + + p = adr; + v = val | (val << 16); + + n = count >> 3; + for (i = 0; i < n; i++) { + p[0] = v; + p[1] = v; + p[2] = v; + p[3] = v; + p += 4; + } + + q = (unsigned short *) p; + n = count & 7; + for (i = 0; i < n; i++) + *q++ = val; +} + +void memset_l(void *adr, int val, int count) +{ + int i, n, v; + unsigned int *p; + + p = adr; + v = val; + n = count >> 2; + for (i = 0; i < n; i++) { + p[0] = v; + p[1] = v; + p[2] = v; + p[3] = v; + p += 4; + } + + n = count & 3; + for (i = 0; i < n; i++) + *p++ = val; +} + +/* count must be a multiple of 4 and >= 4 */ +void memset_RGB24(void *adr,int r, int v, int b,long count) +{ + long i, n; + register long v1,v2,v3,*pt=(long *)(adr); + unsigned char *p,R=(unsigned char)r,V=(unsigned char)v,B=(unsigned char)b; + + p=(unsigned char *)adr; + *p++=R; + *p++=V; + *p++=B; + *p++=R; + *p++=V; + *p++=B; + *p++=R; + *p++=V; + *p++=B; + *p++=R; + *p++=V; + *p++=B; + v1=*pt++; + v2=*pt++; + v3=*pt++; + n = count >> 2; + for(i=1;izbuf, z, zb->xsize * zb->ysize); + } + if (clear_color) { + pp = zb->pbuf; + for (y = 0; y < zb->ysize; y++) { +#if TGL_FEATURE_RENDER_BITS == 15 || TGL_FEATURE_RENDER_BITS == 16 + color = RGB_TO_PIXEL(r, g, b); + memset_s(pp, color, zb->xsize); +#elif TGL_FEATURE_RENDER_BITS == 32 + color = RGB_TO_PIXEL(r, g, b); + memset_l(pp, color, zb->xsize); +#elif TGL_FEATURE_RENDER_BITS == 24 + memset_RGB24(pp,r>>8,g>>8,b>>8,zb->xsize); +#else +#error TODO +#endif + pp = (PIXEL *) ((char *) pp + zb->linesize); + } + } +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/zbuffer.h b/3rdparty/tinygl-0.4-ugfx/src/zbuffer.h new file mode 100644 index 00000000..b73e59fb --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/zbuffer.h @@ -0,0 +1,153 @@ +#ifndef _tgl_zbuffer_h_ +#define _tgl_zbuffer_h_ + +/* + * Z buffer + */ + +#include "zfeatures.h" + +#define ZB_Z_BITS 16 + +#define ZB_POINT_Z_FRAC_BITS 14 + +#define ZB_POINT_S_MIN ( (1<<13) ) +#define ZB_POINT_S_MAX ( (1<<22)-(1<<13) ) +#define ZB_POINT_T_MIN ( (1<<21) ) +#define ZB_POINT_T_MAX ( (1<<30)-(1<<21) ) + +#define ZB_POINT_RED_MIN ( (1<<10) ) +#define ZB_POINT_RED_MAX ( (1<<16)-(1<<10) ) +#define ZB_POINT_GREEN_MIN ( (1<<9) ) +#define ZB_POINT_GREEN_MAX ( (1<<16)-(1<<9) ) +#define ZB_POINT_BLUE_MIN ( (1<<10) ) +#define ZB_POINT_BLUE_MAX ( (1<<16)-(1<<10) ) + +/* display modes */ +#define ZB_MODE_5R6G5B 1 /* true color 16 bits */ +#define ZB_MODE_INDEX 2 /* color index 8 bits */ +#define ZB_MODE_RGBA 3 /* 32 bit rgba mode */ +#define ZB_MODE_RGB24 4 /* 24 bit rgb mode */ +#define ZB_NB_COLORS 225 /* number of colors for 8 bit display */ + +#if TGL_FEATURE_RENDER_BITS == 15 + +#define RGB_TO_PIXEL(r,g,b) \ + ((((r) >> 1) & 0x7c00) | (((g) >> 6) & 0x03e0) | ((b) >> 11)) +typedef unsigned short PIXEL; +/* bytes per pixel */ +#define PSZB 2 +/* bits per pixel = (1 << PSZH) */ +#define PSZSH 4 + +#elif TGL_FEATURE_RENDER_BITS == 16 + +/* 16 bit mode */ +#define RGB_TO_PIXEL(r,g,b) \ + (((r) & 0xF800) | (((g) >> 5) & 0x07E0) | ((b) >> 11)) +typedef unsigned short PIXEL; +#define PSZB 2 +#define PSZSH 4 + +#elif TGL_FEATURE_RENDER_BITS == 24 + +#define RGB_TO_PIXEL(r,g,b) \ + ((((r) << 8) & 0xff0000) | ((g) & 0xff00) | ((b) >> 8)) +typedef unsigned char PIXEL; +#define PSZB 3 +#define PSZSH 5 + +#elif TGL_FEATURE_RENDER_BITS == 32 + +#define RGB_TO_PIXEL(r,g,b) \ + ((((r) << 8) & 0xff0000) | ((g) & 0xff00) | ((b) >> 8)) +typedef unsigned int PIXEL; +#define PSZB 4 +#define PSZSH 5 + +#else + +#error Incorrect number of bits per pixel + +#endif + +typedef struct { + int xsize,ysize; + int linesize; /* line size, in bytes */ + int mode; + + unsigned short *zbuf; + PIXEL *pbuf; + int frame_buffer_allocated; + + int nb_colors; + unsigned char *dctable; + int *ctable; + PIXEL *current_texture; +} ZBuffer; + +typedef struct { + int x,y,z; /* integer coordinates in the zbuffer */ + int s,t; /* coordinates for the mapping */ + int r,g,b; /* color indexes */ + + float sz,tz; /* temporary coordinates for mapping */ +} ZBufferPoint; + +/* zbuffer.c */ + +ZBuffer *ZB_open(int xsize,int ysize,int mode, + int nb_colors, + unsigned char *color_indexes, + int *color_table, + void *frame_buffer); + + +void ZB_close(ZBuffer *zb); + +void ZB_resize(ZBuffer *zb,void *frame_buffer,int xsize,int ysize); +void ZB_clear(ZBuffer *zb,int clear_z,int z, + int clear_color,int r,int g,int b); +/* linesize is in BYTES */ +void ZB_copyFrameBuffer(ZBuffer *zb,void *buf,int linesize); + +/* zdither.c */ + +void ZB_initDither(ZBuffer *zb,int nb_colors, + unsigned char *color_indexes,int *color_table); +void ZB_closeDither(ZBuffer *zb); +void ZB_ditherFrameBuffer(ZBuffer *zb,unsigned char *dest, + int linesize); + +/* zline.c */ + +void ZB_plot(ZBuffer *zb,ZBufferPoint *p); +void ZB_line(ZBuffer *zb,ZBufferPoint *p1,ZBufferPoint *p2); +void ZB_line_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2); + +/* ztriangle.c */ + +void ZB_setTexture(ZBuffer *zb, PIXEL *texture); + +void ZB_fillTriangleFlat(ZBuffer *zb, + ZBufferPoint *p1,ZBufferPoint *p2,ZBufferPoint *p3); + +void ZB_fillTriangleSmooth(ZBuffer *zb, + ZBufferPoint *p1,ZBufferPoint *p2,ZBufferPoint *p3); + +void ZB_fillTriangleMapping(ZBuffer *zb, + ZBufferPoint *p1,ZBufferPoint *p2,ZBufferPoint *p3); + +void ZB_fillTriangleMappingPerspective(ZBuffer *zb, + ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2); + + +typedef void (*ZB_fillTriangleFunc)(ZBuffer *, + ZBufferPoint *,ZBufferPoint *,ZBufferPoint *); + +/* memory.c */ +void gl_free(void *p); +void *gl_malloc(int size); +void *gl_zalloc(int size); + +#endif /* _tgl_zbuffer_h_ */ diff --git a/3rdparty/tinygl-0.4-ugfx/src/zdither.c b/3rdparty/tinygl-0.4-ugfx/src/zdither.c new file mode 100644 index 00000000..cbe917fd --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/zdither.c @@ -0,0 +1,158 @@ +/* + * Highly optimised dithering 16 bits -> 8 bits. + * The formulas were taken in Mesa (Bob Mercier mercier@hollywood.cinenet.net). + */ + +#include +#include +#include "zbuffer.h" +#include + +#if defined(TGL_FEATURE_8_BITS) + +#define _R 5 +#define _G 9 +#define _B 5 +#define _DX 4 +#define _DY 4 +#define _D (_DX*_DY) +#define _MIX(r,g,b) ( ((g)<<6) | ((b)<<3) | (r) ) + +#define DITHER_TABLE_SIZE (1 << 15) + +#define DITHER_INDEX(r,g,b) ((b) + (g) * _B + (r) * (_B * _G)) + +#define MAXC 256 +static int kernel8[_DY*_DX] = { + 0 * MAXC, 8 * MAXC, 2 * MAXC, 10 * MAXC, + 12 * MAXC, 4 * MAXC, 14 * MAXC, 6 * MAXC, + 3 * MAXC, 11 * MAXC, 1 * MAXC, 9 * MAXC, + 15 * MAXC, 7 * MAXC, 13 * MAXC, 5 * MAXC, +}; + +/* we build the color table and the lookup table */ + +void ZB_initDither(ZBuffer *zb,int nb_colors, + unsigned char *color_indexes,int *color_table) +{ + int c,r,g,b,i,index,r1,g1,b1; + + if (nb_colors < (_R * _G * _B)) { + gl_fatal_error("zdither: not enough colors\n"); + } + + for(i=0;inb_colors=nb_colors; + zb->ctable=gl_malloc(nb_colors * sizeof(int)); + + for (r = 0; r < _R; r++) { + for (g = 0; g < _G; g++) { + for (b = 0; b < _B; b++) { + r1=(r*255) / (_R - 1); + g1=(g*255) / (_G - 1); + b1=(b*255) / (_B - 1); + index=DITHER_INDEX(r,g,b); + c=(r1 << 16) | (g1 << 8) | b1; + zb->ctable[index]=c; + color_table[index]=c; + } + } + } + + zb->dctable=gl_malloc( DITHER_TABLE_SIZE ); + + for(i=0;i> 12) & 0x7; + g=(i >> 8) & 0xF; + b=(i >> 3) & 0x7; + index=DITHER_INDEX(r,g,b); + zb->dctable[i]=color_indexes[index]; + } +} + +void ZB_closeDither(ZBuffer *zb) +{ + gl_free(zb->ctable); + gl_free(zb->dctable); +} + +#if 0 +int ZDither_lookupColor(int r,int g,int b) +{ + unsigned char *ctable=zdither_color_table; + return ctable[_MIX(_DITH0(_R, r), _DITH0(_G, g),_DITH0(_B, b))]; +} +#endif + + +#define DITHER_PIXEL2(a) \ +{ \ + register int v,t,r,g,c; \ + v=*(unsigned int *)(pp+(a)); \ + g=(v & 0x07DF07DF) + g_d; \ + r=(((v & 0xF800F800) >> 2) + r_d) & 0x70007000; \ + t=r | g; \ + c=ctable[t & 0xFFFF] | (ctable[t >> 16] << 8); \ + *(unsigned short *)(dest+(a))=c; \ +} + +/* NOTE: all the memory access are 16 bit aligned, so if buf or + linesize are not multiple of 2, it cannot work efficiently (or + hang!) */ + +void ZB_ditherFrameBuffer(ZBuffer *zb,unsigned char *buf, + int linesize) +{ + int xk,yk,x,y,c1,c2; + unsigned char *dest1; + unsigned short *pp1; + int r_d,g_d,b_d; + unsigned char *ctable=zb->dctable; + register unsigned char *dest; + register unsigned short *pp; + + assert( ((long)buf & 1) == 0 && (linesize & 1) == 0); + + for(yk=0;yk<4;yk++) { + for(xk=0;xk<4;xk+=2) { +#if BYTE_ORDER == BIG_ENDIAN + c1=kernel8[yk*4+xk+1]; + c2=kernel8[yk*4+xk]; +#else + c1=kernel8[yk*4+xk]; + c2=kernel8[yk*4+xk+1]; +#endif + r_d=((c1 << 2) & 0xF800) >> 2; + g_d=(c1 >> 4) & 0x07C0; + b_d=(c1 >> 9) & 0x001F; + + r_d|=(((c2 << 2) & 0xF800) >> 2) << 16; + g_d|=((c2 >> 4) & 0x07C0) << 16; + b_d|=((c2 >> 9) & 0x001F) << 16; + g_d=b_d | g_d; + + dest1=buf + (yk * linesize) + xk; + pp1=zb->pbuf + (yk * zb->xsize) + xk; + + for(y=yk;yysize;y+=4) { + dest=dest1; + pp=pp1; + for(x=xk;xxsize;x+=16) { + + DITHER_PIXEL2(0); + DITHER_PIXEL2(1*4); + DITHER_PIXEL2(2*4); + DITHER_PIXEL2(3*4); + + pp+=16; + dest+=16; + } + dest1+=linesize*4; + pp1+=zb->xsize*4; + } + } + } +} + +#endif diff --git a/3rdparty/tinygl-0.4-ugfx/src/zfeatures.h b/3rdparty/tinygl-0.4-ugfx/src/zfeatures.h new file mode 100644 index 00000000..cafe0c20 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/zfeatures.h @@ -0,0 +1,43 @@ +#ifndef _tgl_features_h_ +#define _tgl_features_h_ + +/* It is possible to enable/disable (compile time) features in this + header file. */ + +#define TGL_FEATURE_ARRAYS 1 +#define TGL_FEATURE_DISPLAYLISTS 1 +#define TGL_FEATURE_POLYGON_OFFSET 1 + +/* + * Matrix of internal and external pixel formats supported. 'Y' means + * supported. + * + * External 8 16 24 32 + * Internal + * 15 . . . . + * 16 Y Y Y Y + * 24 . Y Y . + * 32 . Y . Y + * + * + * 15 bpp does not work yet (although it is easy to add it - ask me if + * you need it). + * + * Internal pixel format: see TGL_FEATURE_RENDER_BITS + * External pixel format: see TGL_FEATURE_xxx_BITS + */ + +/* enable various convertion code from internal pixel format (usually + 16 bits per pixel) to any external format */ +#define TGL_FEATURE_16_BITS 1 +#define TGL_FEATURE_8_BITS 1 +#define TGL_FEATURE_24_BITS 1 +#define TGL_FEATURE_32_BITS 1 + + +//#define TGL_FEATURE_RENDER_BITS 15 +#define TGL_FEATURE_RENDER_BITS 16 +//#define TGL_FEATURE_RENDER_BITS 24 +//#define TGL_FEATURE_RENDER_BITS 32 + +#endif /* _tgl_features_h_ */ diff --git a/3rdparty/tinygl-0.4-ugfx/src/zgl.h b/3rdparty/tinygl-0.4-ugfx/src/zgl.h new file mode 100644 index 00000000..f9e0578a --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/zgl.h @@ -0,0 +1,372 @@ +#ifndef _tgl_zgl_h_ +#define _tgl_zgl_h_ + +#include +#include +#include +#include +#include "zbuffer.h" +#include "zmath.h" +#include "zfeatures.h" + +#define DEBUG +/* #define NDEBUG */ + +enum { + +#define ADD_OP(a,b,c) OP_ ## a , + +#include "opinfo.h" + +}; + +/* initially # of allocated GLVertexes (will grow when necessary) */ +#define POLYGON_MAX_VERTEX 16 + +/* Max # of specular light pow buffers */ +#define MAX_SPECULAR_BUFFERS 8 +/* # of entries in specular buffer */ +#define SPECULAR_BUFFER_SIZE 1024 +/* specular buffer granularity */ +#define SPECULAR_BUFFER_RESOLUTION 1024 + + +#define MAX_MODELVIEW_STACK_DEPTH 32 +#define MAX_PROJECTION_STACK_DEPTH 8 +#define MAX_TEXTURE_STACK_DEPTH 8 +#define MAX_NAME_STACK_DEPTH 64 +#define MAX_TEXTURE_LEVELS 11 +#define MAX_LIGHTS 16 + +#define VERTEX_HASH_SIZE 1031 + +#define MAX_DISPLAY_LISTS 1024 +#define OP_BUFFER_MAX_SIZE 512 + +#define TGL_OFFSET_FILL 0x1 +#define TGL_OFFSET_LINE 0x2 +#define TGL_OFFSET_POINT 0x4 + +typedef struct GLSpecBuf { + int shininess_i; + int last_used; + float buf[SPECULAR_BUFFER_SIZE+1]; + struct GLSpecBuf *next; +} GLSpecBuf; + +typedef struct GLLight { + V4 ambient; + V4 diffuse; + V4 specular; + V4 position; + V3 spot_direction; + float spot_exponent; + float spot_cutoff; + float attenuation[3]; + /* precomputed values */ + float cos_spot_cutoff; + V3 norm_spot_direction; + V3 norm_position; + /* we use a linked list to know which are the enabled lights */ + int enabled; + struct GLLight *next,*prev; +} GLLight; + +typedef struct GLMaterial { + V4 emission; + V4 ambient; + V4 diffuse; + V4 specular; + float shininess; + + /* computed values */ + int shininess_i; + int do_specular; +} GLMaterial; + + +typedef struct GLViewport { + int xmin,ymin,xsize,ysize; + V3 scale; + V3 trans; + int updated; +} GLViewport; + +typedef union { + int op; + float f; + int i; + unsigned int ui; + void *p; +} GLParam; + +typedef struct GLParamBuffer { + GLParam ops[OP_BUFFER_MAX_SIZE]; + struct GLParamBuffer *next; +} GLParamBuffer; + +typedef struct GLList { + GLParamBuffer *first_op_buffer; + /* TODO: extensions for an hash table or a better allocating scheme */ +} GLList; + +typedef struct GLVertex { + int edge_flag; + V3 normal; + V4 coord; + V4 tex_coord; + V4 color; + + /* computed values */ + V4 ec; /* eye coordinates */ + V4 pc; /* coordinates in the normalized volume */ + int clip_code; /* clip code */ + ZBufferPoint zp; /* integer coordinates for the rasterization */ +} GLVertex; + +typedef struct GLImage { + void *pixmap; + int xsize,ysize; +} GLImage; + +/* textures */ + +#define TEXTURE_HASH_TABLE_SIZE 256 + +typedef struct GLTexture { + GLImage images[MAX_TEXTURE_LEVELS]; + int handle; + struct GLTexture *next,*prev; +} GLTexture; + + +/* shared state */ + +typedef struct GLSharedState { + GLList **lists; + GLTexture **texture_hash_table; +} GLSharedState; + +struct GLContext; + +typedef void (*gl_draw_triangle_func)(struct GLContext *c, + GLVertex *p0,GLVertex *p1,GLVertex *p2); + +/* display context */ + +typedef struct GLContext { + /* Z buffer */ + ZBuffer *zb; + + /* lights */ + GLLight lights[MAX_LIGHTS]; + GLLight *first_light; + V4 ambient_light_model; + int local_light_model; + int lighting_enabled; + int light_model_two_side; + + /* materials */ + GLMaterial materials[2]; + int color_material_enabled; + int current_color_material_mode; + int current_color_material_type; + + /* textures */ + GLTexture *current_texture; + int texture_2d_enabled; + + /* shared state */ + GLSharedState shared_state; + + /* current list */ + GLParamBuffer *current_op_buffer; + int current_op_buffer_index; + int exec_flag,compile_flag,print_flag; + + /* matrix */ + + int matrix_mode; + M4 *matrix_stack[3]; + M4 *matrix_stack_ptr[3]; + int matrix_stack_depth_max[3]; + + M4 matrix_model_view_inv; + M4 matrix_model_projection; + int matrix_model_projection_updated; + int matrix_model_projection_no_w_transform; + int apply_texture_matrix; + + /* viewport */ + GLViewport viewport; + + /* current state */ + int polygon_mode_back; + int polygon_mode_front; + + int current_front_face; + int current_shade_model; + int current_cull_face; + int cull_face_enabled; + int normalize_enabled; + gl_draw_triangle_func draw_triangle_front,draw_triangle_back; + + /* selection */ + int render_mode; + unsigned int *select_buffer; + int select_size; + unsigned int *select_ptr,*select_hit; + int select_overflow; + int select_hits; + + /* names */ + unsigned int name_stack[MAX_NAME_STACK_DEPTH]; + int name_stack_size; + + /* clear */ + float clear_depth; + V4 clear_color; + + /* current vertex state */ + V4 current_color; + unsigned int longcurrent_color[3]; /* precomputed integer color */ + V4 current_normal; + V4 current_tex_coord; + int current_edge_flag; + + /* glBegin / glEnd */ + int in_begin; + int begin_type; + int vertex_n,vertex_cnt; + int vertex_max; + GLVertex *vertex; + + /* opengl 1.1 arrays */ + float *vertex_array; + int vertex_array_size; + int vertex_array_stride; + float *normal_array; + int normal_array_stride; + float *color_array; + int color_array_size; + int color_array_stride; + float *texcoord_array; + int texcoord_array_size; + int texcoord_array_stride; + int client_states; + + /* opengl 1.1 polygon offset */ + float offset_factor; + float offset_units; + int offset_states; + + /* specular buffer. could probably be shared between contexts, + but that wouldn't be 100% thread safe */ + GLSpecBuf *specbuf_first; + int specbuf_used_counter; + int specbuf_num_buffers; + + /* opaque structure for user's use */ + void *opaque; + /* resize viewport function */ + int (*gl_resize_viewport)(struct GLContext *c,int *xsize,int *ysize); + + /* depth test */ + int depth_test; +} GLContext; + +extern GLContext *gl_ctx; + +void gl_add_op(GLParam *p); + +/* clip.c */ +void gl_transform_to_viewport(GLContext *c,GLVertex *v); +void gl_draw_triangle(GLContext *c,GLVertex *p0,GLVertex *p1,GLVertex *p2); +void gl_draw_line(GLContext *c,GLVertex *p0,GLVertex *p1); +void gl_draw_point(GLContext *c,GLVertex *p0); + +void gl_draw_triangle_point(GLContext *c, + GLVertex *p0,GLVertex *p1,GLVertex *p2); +void gl_draw_triangle_line(GLContext *c, + GLVertex *p0,GLVertex *p1,GLVertex *p2); +void gl_draw_triangle_fill(GLContext *c, + GLVertex *p0,GLVertex *p1,GLVertex *p2); +void gl_draw_triangle_select(GLContext *c, + GLVertex *p0,GLVertex *p1,GLVertex *p2); + +/* matrix.c */ +void gl_print_matrix(const float *m); +/* +void glopLoadIdentity(GLContext *c,GLParam *p); +void glopTranslate(GLContext *c,GLParam *p);*/ + +/* light.c */ +void gl_add_select(GLContext *c,unsigned int zmin,unsigned int zmax); +void gl_enable_disable_light(GLContext *c,int light,int v); +void gl_shade_vertex(GLContext *c,GLVertex *v); + +void glInitTextures(GLContext *c); +void glEndTextures(GLContext *c); +GLTexture *alloc_texture(GLContext *c,int h); + +/* image_util.c */ +void gl_convertRGB_to_5R6G5B(unsigned short *pixmap,unsigned char *rgb, + int xsize,int ysize); +void gl_convertRGB_to_8A8R8G8B(unsigned int *pixmap, unsigned char *rgb, + int xsize, int ysize); +void gl_resizeImage(unsigned char *dest,int xsize_dest,int ysize_dest, + unsigned char *src,int xsize_src,int ysize_src); +void gl_resizeImageNoInterpolate(unsigned char *dest,int xsize_dest,int ysize_dest, + unsigned char *src,int xsize_src,int ysize_src); + +GLContext *gl_get_context(void); + +void gl_fatal_error(char *format, ...); +void gl_assert(int test); + + +/* specular buffer "api" */ +GLSpecBuf *specbuf_get_buffer(GLContext *c, const int shininess_i, + const float shininess); + +#ifdef __BEOS__ +void dprintf(const char *, ...); + +#else /* !BEOS */ + +#ifdef DEBUG + +#define dprintf(format, args...) \ + fprintf(stderr,"In '%s': " format "\n",__FUNCTION__, ##args); + +#else + +#define dprintf(format, args...) + +#endif +#endif /* !BEOS */ + +/* glopXXX functions */ + +#define ADD_OP(a,b,c) void glop ## a (GLContext *,GLParam *); +#include "opinfo.h" + +/* this clip epsilon is needed to avoid some rounding errors after + several clipping stages */ + +#define CLIP_EPSILON (1E-5) + +static inline int gl_clipcode(float x,float y,float z,float w1) +{ + float w; + + w=w1 * (1.0 + CLIP_EPSILON); + return (x<-w) | + ((x>w)<<1) | + ((y<-w)<<2) | + ((y>w)<<3) | + ((z<-w)<<4) | + ((z>w)<<5) ; +} + +#endif /* _tgl_zgl_h_ */ diff --git a/3rdparty/tinygl-0.4-ugfx/src/zline.c b/3rdparty/tinygl-0.4-ugfx/src/zline.c new file mode 100644 index 00000000..561064b0 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/zline.c @@ -0,0 +1,84 @@ +#include +#include "zbuffer.h" + +#define ZCMP(z,zpix) ((z) >= (zpix)) + +void ZB_plot(ZBuffer * zb, ZBufferPoint * p) +{ + unsigned short *pz; + PIXEL *pp; + int zz; + + pz = zb->zbuf + (p->y * zb->xsize + p->x); + pp = (PIXEL *) ((char *) zb->pbuf + zb->linesize * p->y + p->x * PSZB); + zz = p->z >> ZB_POINT_Z_FRAC_BITS; + if (ZCMP(zz, *pz)) { +#if TGL_FEATURE_RENDER_BITS == 24 + pp[0]=p->r>>8; + pp[1]=p->g>>8; + pp[2]=p->b>>8; +#else + *pp = RGB_TO_PIXEL(p->r, p->g, p->b); +#endif + *pz = zz; + } +} + +#define INTERP_Z +static void ZB_line_flat_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2, + int color) +{ +#include "zline.h" +} + +/* line with color interpolation */ +#define INTERP_Z +#define INTERP_RGB +static void ZB_line_interp_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2) +{ +#include "zline.h" +} + +/* no Z interpolation */ + +static void ZB_line_flat(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2, + int color) +{ +#include "zline.h" +} + +#define INTERP_RGB +static void ZB_line_interp(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2) +{ +#include "zline.h" +} + +void ZB_line_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2) +{ + int color1, color2; + + color1 = RGB_TO_PIXEL(p1->r, p1->g, p1->b); + color2 = RGB_TO_PIXEL(p2->r, p2->g, p2->b); + + /* choose if the line should have its color interpolated or not */ + if (color1 == color2) { + ZB_line_flat_z(zb, p1, p2, color1); + } else { + ZB_line_interp_z(zb, p1, p2); + } +} + +void ZB_line(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2) +{ + int color1, color2; + + color1 = RGB_TO_PIXEL(p1->r, p1->g, p1->b); + color2 = RGB_TO_PIXEL(p2->r, p2->g, p2->b); + + /* choose if the line should have its color interpolated or not */ + if (color1 == color2) { + ZB_line_flat(zb, p1, p2, color1); + } else { + ZB_line_interp(zb, p1, p2); + } +} diff --git a/3rdparty/tinygl-0.4-ugfx/src/zline.h b/3rdparty/tinygl-0.4-ugfx/src/zline.h new file mode 100644 index 00000000..00408b45 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/zline.h @@ -0,0 +1,122 @@ +{ + int n, dx, dy, sx, pp_inc_1, pp_inc_2; + register int a; + register PIXEL *pp; +#if defined(INTERP_RGB) || TGL_FEATURE_RENDER_BITS == 24 + register unsigned int r, g, b; +#endif +#ifdef INTERP_RGB + register unsigned int rinc, ginc, binc; +#endif +#ifdef INTERP_Z + register unsigned short *pz; + int zinc; + register int z, zz; +#endif + + if (p1->y > p2->y || (p1->y == p2->y && p1->x > p2->x)) { + ZBufferPoint *tmp; + tmp = p1; + p1 = p2; + p2 = tmp; + } + sx = zb->xsize; + pp = (PIXEL *) ((char *) zb->pbuf + zb->linesize * p1->y + p1->x * PSZB); +#ifdef INTERP_Z + pz = zb->zbuf + (p1->y * sx + p1->x); + z = p1->z; +#endif + + dx = p2->x - p1->x; + dy = p2->y - p1->y; +#ifdef INTERP_RGB + r = p2->r << 8; + g = p2->g << 8; + b = p2->b << 8; +#elif TGL_FEATURE_RENDER_BITS == 24 + /* for 24 bits, we store the colors in different variables */ + r = p2->r >> 8; + g = p2->g >> 8; + b = p2->b >> 8; +#endif + +#undef RGB +#ifdef INTERP_RGB +#define RGB(x) x +#if TGL_FEATURE_RENDER_BITS == 24 +#define RGBPIXEL pp[0] = r >> 16, pp[1] = g >> 16, pp[2] = b >> 16 +#else +#define RGBPIXEL *pp = RGB_TO_PIXEL(r >> 8,g >> 8,b >> 8) +#endif +#else /* INTERP_RGB */ +#define RGB(x) +#if TGL_FEATURE_RENDER_BITS == 24 +#define RGBPIXEL pp[0] = r, pp[1] = g, pp[2] = b +#else +#define RGBPIXEL *pp = color +#endif +#endif /* INTERP_RGB */ + +#ifdef INTERP_Z +#define ZZ(x) x +#define PUTPIXEL() \ + { \ + zz=z >> ZB_POINT_Z_FRAC_BITS; \ + if (ZCMP(zz,*pz)) { \ + RGBPIXEL; \ + *pz=zz; \ + } \ + } +#else /* INTERP_Z */ +#define ZZ(x) +#define PUTPIXEL() RGBPIXEL +#endif /* INTERP_Z */ + +#define DRAWLINE(dx,dy,inc_1,inc_2) \ + n=dx;\ + ZZ(zinc=(p2->z-p1->z)/n);\ + RGB(rinc=((p2->r-p1->r) << 8)/n;\ + ginc=((p2->g-p1->g) << 8)/n;\ + binc=((p2->b-p1->b) << 8)/n);\ + a=2*dy-dx;\ + dy=2*dy;\ + dx=2*dx-dy;\ + pp_inc_1 = (inc_1) * PSZB;\ + pp_inc_2 = (inc_2) * PSZB;\ + do {\ + PUTPIXEL();\ + ZZ(z+=zinc);\ + RGB(r+=rinc;g+=ginc;b+=binc);\ + if (a>0) { pp=(PIXEL *)((char *)pp + pp_inc_1); ZZ(pz+=(inc_1)); a-=dx; }\ + else { pp=(PIXEL *)((char *)pp + pp_inc_2); ZZ(pz+=(inc_2)); a+=dy; }\ + } while (--n >= 0); + +/* fin macro */ + + if (dx == 0 && dy == 0) { + PUTPIXEL(); + } else if (dx > 0) { + if (dx >= dy) { + DRAWLINE(dx, dy, sx + 1, 1); + } else { + DRAWLINE(dy, dx, sx + 1, sx); + } + } else { + dx = -dx; + if (dx >= dy) { + DRAWLINE(dx, dy, sx - 1, -1); + } else { + DRAWLINE(dy, dx, sx - 1, sx); + } + } +} + +#undef INTERP_Z +#undef INTERP_RGB + +/* internal defines */ +#undef DRAWLINE +#undef PUTPIXEL +#undef ZZ +#undef RGB +#undef RGBPIXEL diff --git a/3rdparty/tinygl-0.4-ugfx/src/zmath.c b/3rdparty/tinygl-0.4-ugfx/src/zmath.c new file mode 100644 index 00000000..8ef48d48 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/zmath.c @@ -0,0 +1,275 @@ +/* Some simple mathematical functions. Don't look for some logic in + the function names :-) */ + +#include +#include +#include +#include "zmath.h" + + +/* ******* Gestion des matrices 4x4 ****** */ + +void gl_M4_Id(M4 *a) +{ + int i,j; + for(i=0;i<4;i++) + for(j=0;j<4;j++) + if (i==j) a->m[i][j]=1.0; else a->m[i][j]=0.0; +} + +int gl_M4_IsId(M4 *a) +{ + int i,j; + for(i=0;i<4;i++) + for(j=0;j<4;j++) { + if (i==j) { + if (a->m[i][j] != 1.0) return 0; + } else if (a->m[i][j] != 0.0) return 0; + } + return 1; +} + +void gl_M4_Mul(M4 *c,M4 *a,M4 *b) +{ + int i,j,k; + float s; + for(i=0;i<4;i++) + for(j=0;j<4;j++) { + s=0.0; + for(k=0;k<4;k++) s+=a->m[i][k]*b->m[k][j]; + c->m[i][j]=s; + } +} + +/* c=c*a */ +void gl_M4_MulLeft(M4 *c,M4 *b) +{ + int i,j,k; + float s; + M4 a; + + /*memcpy(&a, c, 16*sizeof(float)); + */ + a=*c; + + for(i=0;i<4;i++) + for(j=0;j<4;j++) { + s=0.0; + for(k=0;k<4;k++) s+=a.m[i][k]*b->m[k][j]; + c->m[i][j]=s; + } +} + +void gl_M4_Move(M4 *a,M4 *b) +{ + memcpy(a,b,sizeof(M4)); +} + +void gl_MoveV3(V3 *a,V3 *b) +{ + memcpy(a,b,sizeof(V3)); +} + + +void gl_MulM4V3(V3 *a,M4 *b,V3 *c) +{ + a->X=b->m[0][0]*c->X+b->m[0][1]*c->Y+b->m[0][2]*c->Z+b->m[0][3]; + a->Y=b->m[1][0]*c->X+b->m[1][1]*c->Y+b->m[1][2]*c->Z+b->m[1][3]; + a->Z=b->m[2][0]*c->X+b->m[2][1]*c->Y+b->m[2][2]*c->Z+b->m[2][3]; +} + +void gl_MulM3V3(V3 *a,M4 *b,V3 *c) +{ + a->X=b->m[0][0]*c->X+b->m[0][1]*c->Y+b->m[0][2]*c->Z; + a->Y=b->m[1][0]*c->X+b->m[1][1]*c->Y+b->m[1][2]*c->Z; + a->Z=b->m[2][0]*c->X+b->m[2][1]*c->Y+b->m[2][2]*c->Z; +} + +void gl_M4_MulV4(V4 *a,M4 *b,V4 *c) +{ + a->X=b->m[0][0]*c->X+b->m[0][1]*c->Y+b->m[0][2]*c->Z+b->m[0][3]*c->W; + a->Y=b->m[1][0]*c->X+b->m[1][1]*c->Y+b->m[1][2]*c->Z+b->m[1][3]*c->W; + a->Z=b->m[2][0]*c->X+b->m[2][1]*c->Y+b->m[2][2]*c->Z+b->m[2][3]*c->W; + a->W=b->m[3][0]*c->X+b->m[3][1]*c->Y+b->m[3][2]*c->Z+b->m[3][3]*c->W; +} + +/* transposition of a 4x4 matrix */ +void gl_M4_Transpose(M4 *a,M4 *b) +{ + a->m[0][0]=b->m[0][0]; + a->m[0][1]=b->m[1][0]; + a->m[0][2]=b->m[2][0]; + a->m[0][3]=b->m[3][0]; + + a->m[1][0]=b->m[0][1]; + a->m[1][1]=b->m[1][1]; + a->m[1][2]=b->m[2][1]; + a->m[1][3]=b->m[3][1]; + + a->m[2][0]=b->m[0][2]; + a->m[2][1]=b->m[1][2]; + a->m[2][2]=b->m[2][2]; + a->m[2][3]=b->m[3][2]; + + a->m[3][0]=b->m[0][3]; + a->m[3][1]=b->m[1][3]; + a->m[3][2]=b->m[2][3]; + a->m[3][3]=b->m[3][3]; +} + +/* inversion of an orthogonal matrix of type Y=M.X+P */ +void gl_M4_InvOrtho(M4 *a,M4 b) +{ + int i,j; + float s; + for(i=0;i<3;i++) + for(j=0;j<3;j++) a->m[i][j]=b.m[j][i]; + a->m[3][0]=0.0; a->m[3][1]=0.0; a->m[3][2]=0.0; a->m[3][3]=1.0; + for(i=0;i<3;i++) { + s=0; + for(j=0;j<3;j++) s-=b.m[j][i]*b.m[j][3]; + a->m[i][3]=s; + } +} + +/* Inversion of a general nxn matrix. + Note : m is destroyed */ + +int Matrix_Inv(float *r,float *m,int n) +{ + int i,j,k,l; + float max,tmp,t; + + /* identitée dans r */ + for(i=0;ifabs(max)) { + k=i; + max=m[i*n+j]; + } + + /* non intersible matrix */ + if (max==0) return 1; + + + /* permutation des lignes j et k */ + if (k!=j) { + for(i=0;im[0][0],&tmp.m[0][0],4); +} + +void gl_M4_Rotate(M4 *a,float t,int u) +{ + float s,c; + int v,w; + if ((v=u+1)>2) v=0; + if ((w=v+1)>2) w=0; + s=sin(t); + c=cos(t); + gl_M4_Id(a); + a->m[v][v]=c; a->m[v][w]=-s; + a->m[w][v]=s; a->m[w][w]=c; +} + + +/* inverse of a 3x3 matrix */ +void gl_M3_Inv(M3 *a,M3 *m) +{ + float det; + + det = m->m[0][0]*m->m[1][1]*m->m[2][2]-m->m[0][0]*m->m[1][2]*m->m[2][1]- + m->m[1][0]*m->m[0][1]*m->m[2][2]+m->m[1][0]*m->m[0][2]*m->m[2][1]+ + m->m[2][0]*m->m[0][1]*m->m[1][2]-m->m[2][0]*m->m[0][2]*m->m[1][1]; + + a->m[0][0] = (m->m[1][1]*m->m[2][2]-m->m[1][2]*m->m[2][1])/det; + a->m[0][1] = -(m->m[0][1]*m->m[2][2]-m->m[0][2]*m->m[2][1])/det; + a->m[0][2] = -(-m->m[0][1]*m->m[1][2]+m->m[0][2]*m->m[1][1])/det; + + a->m[1][0] = -(m->m[1][0]*m->m[2][2]-m->m[1][2]*m->m[2][0])/det; + a->m[1][1] = (m->m[0][0]*m->m[2][2]-m->m[0][2]*m->m[2][0])/det; + a->m[1][2] = -(m->m[0][0]*m->m[1][2]-m->m[0][2]*m->m[1][0])/det; + + a->m[2][0] = (m->m[1][0]*m->m[2][1]-m->m[1][1]*m->m[2][0])/det; + a->m[2][1] = -(m->m[0][0]*m->m[2][1]-m->m[0][1]*m->m[2][0])/det; + a->m[2][2] = (m->m[0][0]*m->m[1][1]-m->m[0][1]*m->m[1][0])/det; +} + + +/* vector arithmetic */ + +int gl_V3_Norm(V3 *a) +{ + float n; + n=sqrt(a->X*a->X+a->Y*a->Y+a->Z*a->Z); + if (n==0) return 1; + a->X/=n; + a->Y/=n; + a->Z/=n; + return 0; +} + +V3 gl_V3_New(float x,float y,float z) +{ + V3 a; + a.X=x; + a.Y=y; + a.Z=z; + return a; +} + +V4 gl_V4_New(float x,float y,float z,float w) +{ + V4 a; + a.X=x; + a.Y=y; + a.Z=z; + a.W=w; + return a; +} + + diff --git a/3rdparty/tinygl-0.4-ugfx/src/zmath.h b/3rdparty/tinygl-0.4-ugfx/src/zmath.h new file mode 100644 index 00000000..325e408e --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/zmath.h @@ -0,0 +1,53 @@ +#ifndef __ZMATH__ +#define __ZMATH__ + +/* Matrix & Vertex */ + +typedef struct { + float m[4][4]; +} M4; + +typedef struct { + float m[3][3]; +} M3; + +typedef struct { + float m[3][4]; +} M34; + + +#define X v[0] +#define Y v[1] +#define Z v[2] +#define W v[3] + +typedef struct { + float v[3]; +} V3; + +typedef struct { + float v[4]; +} V4; + +void gl_M4_Id(M4 *a); +int gl_M4_IsId(M4 *a); +void gl_M4_Move(M4 *a,M4 *b); +void gl_MoveV3(V3 *a,V3 *b); +void gl_MulM4V3(V3 *a,M4 *b,V3 *c); +void gl_MulM3V3(V3 *a,M4 *b,V3 *c); + +void gl_M4_MulV4(V4 * a,M4 *b,V4 * c); +void gl_M4_InvOrtho(M4 *a,M4 b); +void gl_M4_Inv(M4 *a,M4 *b); +void gl_M4_Mul(M4 *c,M4 *a,M4 *b); +void gl_M4_MulLeft(M4 *c,M4 *a); +void gl_M4_Transpose(M4 *a,M4 *b); +void gl_M4_Rotate(M4 *c,float t,int u); +int gl_V3_Norm(V3 *a); + +V3 gl_V3_New(float x,float y,float z); +V4 gl_V4_New(float x,float y,float z,float w); + +int gl_Matrix_Inv(float *r,float *m,int n); + +#endif //__ZMATH__ diff --git a/3rdparty/tinygl-0.4-ugfx/src/ztriangle.c b/3rdparty/tinygl-0.4-ugfx/src/ztriangle.c new file mode 100644 index 00000000..366d75c5 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/ztriangle.c @@ -0,0 +1,394 @@ +#include +#include "zbuffer.h" + +#define ZCMP(z,zpix) ((z) >= (zpix)) + +void ZB_fillTriangleFlat(ZBuffer *zb, + ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2) +{ +#if TGL_FEATURE_RENDER_BITS == 24 + unsigned char colorR, colorG, colorB; +#else + int color; +#endif + +#define INTERP_Z + +#if TGL_FEATURE_RENDER_BITS == 24 + +#define DRAW_INIT() \ +{ \ + colorR=p2->r>>8; \ + colorG=p2->g>>8; \ + colorB=p2->b>>8; \ +} + +#define PUT_PIXEL(_a) \ +{ \ + zz=z >> ZB_POINT_Z_FRAC_BITS; \ + if (ZCMP(zz,pz[_a])) { \ + pp[3 * _a]=colorR;\ + pp[3 * _a + 1]=colorG;\ + pp[3 * _a + 2]=colorB;\ + pz[_a]=zz; \ + }\ + z+=dzdx; \ +} + +#else + +#define DRAW_INIT() \ +{ \ + color=RGB_TO_PIXEL(p2->r,p2->g,p2->b); \ +} + +#define PUT_PIXEL(_a) \ +{ \ + zz=z >> ZB_POINT_Z_FRAC_BITS; \ + if (ZCMP(zz,pz[_a])) { \ + pp[_a]=color; \ + pz[_a]=zz; \ + } \ + z+=dzdx; \ +} +#endif /* TGL_FEATURE_RENDER_BITS == 24 */ + +#include "ztriangle.h" +} + +/* + * Smooth filled triangle. + * The code below is very tricky :) + */ + +void ZB_fillTriangleSmooth(ZBuffer *zb, + ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2) +{ +#if TGL_FEATURE_RENDER_BITS == 16 + int _drgbdx; +#endif + +#define INTERP_Z +#define INTERP_RGB + +#define SAR_RND_TO_ZERO(v,n) (v / (1<> ZB_POINT_Z_FRAC_BITS; \ + if (ZCMP(zz,pz[_a])) { \ + pp[3 * _a]=or1 >> 8;\ + pp[3 * _a + 1]=og1 >> 8;\ + pp[3 * _a + 2]=ob1 >> 8;\ + pz[_a]=zz; \ + }\ + z+=dzdx; \ + og1+=dgdx; \ + or1+=drdx; \ + ob1+=dbdx; \ +} + +#elif TGL_FEATURE_RENDER_BITS == 16 + +#define DRAW_INIT() \ +{ \ + _drgbdx=(SAR_RND_TO_ZERO(drdx,6) << 22) & 0xFFC00000; \ + _drgbdx|=SAR_RND_TO_ZERO(dgdx,5) & 0x000007FF; \ + _drgbdx|=(SAR_RND_TO_ZERO(dbdx,7) << 12) & 0x001FF000; \ +} + + +#define PUT_PIXEL(_a) \ +{ \ + zz=z >> ZB_POINT_Z_FRAC_BITS; \ + if (ZCMP(zz,pz[_a])) { \ + tmp=rgb & 0xF81F07E0; \ + pp[_a]=tmp | (tmp >> 16); \ + pz[_a]=zz; \ + } \ + z+=dzdx; \ + rgb=(rgb+drgbdx) & ( ~ 0x00200800); \ +} + +#define DRAW_LINE() \ +{ \ + register unsigned short *pz; \ + register PIXEL *pp; \ + register unsigned int tmp,z,zz,rgb,drgbdx; \ + register int n; \ + n=(x2 >> 16) - x1; \ + pp=pp1+x1; \ + pz=pz1+x1; \ + z=z1; \ + rgb=(r1 << 16) & 0xFFC00000; \ + rgb|=(g1 >> 5) & 0x000007FF; \ + rgb|=(b1 << 5) & 0x001FF000; \ + drgbdx=_drgbdx; \ + while (n>=3) { \ + PUT_PIXEL(0); \ + PUT_PIXEL(1); \ + PUT_PIXEL(2); \ + PUT_PIXEL(3); \ + pz+=4; \ + pp+=4; \ + n-=4; \ + } \ + while (n>=0) { \ + PUT_PIXEL(0); \ + pz+=1; \ + pp+=1; \ + n-=1; \ + } \ +} + +#else + +#define DRAW_INIT() \ +{ \ +} + +#define PUT_PIXEL(_a) \ +{ \ + zz=z >> ZB_POINT_Z_FRAC_BITS; \ + if (ZCMP(zz,pz[_a])) { \ + pp[_a] = RGB_TO_PIXEL(or1, og1, ob1);\ + pz[_a]=zz; \ + }\ + z+=dzdx; \ + og1+=dgdx; \ + or1+=drdx; \ + ob1+=dbdx; \ +} + +#endif /* TGL_FEATURE_RENDER_BITS */ + +#include "ztriangle.h" +} + +void ZB_setTexture(ZBuffer *zb,PIXEL *texture) +{ + zb->current_texture=texture; +} + +void ZB_fillTriangleMapping(ZBuffer *zb, + ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2) +{ + PIXEL *texture; + +#define INTERP_Z +#define INTERP_ST + +#define DRAW_INIT() \ +{ \ + texture=zb->current_texture; \ +} + +#if TGL_FEATURE_RENDER_BITS == 24 + +#define PUT_PIXEL(_a) \ +{ \ + unsigned char *ptr;\ + zz=z >> ZB_POINT_Z_FRAC_BITS; \ + if (ZCMP(zz,pz[_a])) { \ + ptr = texture + (((t & 0x3FC00000) | s) >> 14) * 3; \ + pp[3 * _a]= ptr[0];\ + pp[3 * _a + 1]= ptr[1];\ + pp[3 * _a + 2]= ptr[2];\ + pz[_a]=zz; \ + } \ + z+=dzdx; \ + s+=dsdx; \ + t+=dtdx; \ +} + +#else + +#define PUT_PIXEL(_a) \ +{ \ + zz=z >> ZB_POINT_Z_FRAC_BITS; \ + if (ZCMP(zz,pz[_a])) { \ + pp[_a]=texture[((t & 0x3FC00000) | s) >> 14]; \ + pz[_a]=zz; \ + } \ + z+=dzdx; \ + s+=dsdx; \ + t+=dtdx; \ +} + +#endif + +#include "ztriangle.h" +} + +/* + * Texture mapping with perspective correction. + * We use the gradient method to make less divisions. + * TODO: pipeline the division + */ +#if 1 + +void ZB_fillTriangleMappingPerspective(ZBuffer *zb, + ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2) +{ + PIXEL *texture; + float fdzdx,fndzdx,ndszdx,ndtzdx; + +#define INTERP_Z +#define INTERP_STZ + +#define NB_INTERP 8 + +#define DRAW_INIT() \ +{ \ + texture=zb->current_texture;\ + fdzdx=(float)dzdx;\ + fndzdx=NB_INTERP * fdzdx;\ + ndszdx=NB_INTERP * dszdx;\ + ndtzdx=NB_INTERP * dtzdx;\ +} + + +#if TGL_FEATURE_RENDER_BITS == 24 + +#define PUT_PIXEL(_a) \ +{ \ + unsigned char *ptr;\ + zz=z >> ZB_POINT_Z_FRAC_BITS; \ + if (ZCMP(zz,pz[_a])) { \ + ptr = texture + (((t & 0x3FC00000) | (s & 0x003FC000)) >> 14) * 3;\ + pp[3 * _a]= ptr[0];\ + pp[3 * _a + 1]= ptr[1];\ + pp[3 * _a + 2]= ptr[2];\ + pz[_a]=zz; \ + } \ + z+=dzdx; \ + s+=dsdx; \ + t+=dtdx; \ +} + +#else + +#define PUT_PIXEL(_a) \ +{ \ + zz=z >> ZB_POINT_Z_FRAC_BITS; \ + if (ZCMP(zz,pz[_a])) { \ + pp[_a]=*(PIXEL *)((char *)texture+ \ + (((t & 0x3FC00000) | (s & 0x003FC000)) >> (17 - PSZSH)));\ + pz[_a]=zz; \ + } \ + z+=dzdx; \ + s+=dsdx; \ + t+=dtdx; \ +} + +#endif + +#define DRAW_LINE() \ +{ \ + register unsigned short *pz; \ + register PIXEL *pp; \ + register unsigned int s,t,z,zz; \ + register int n,dsdx,dtdx; \ + float sz,tz,fz,zinv; \ + n=(x2>>16)-x1; \ + fz=(float)z1;\ + zinv=1.0 / fz;\ + pp=(PIXEL *)((char *)pp1 + x1 * PSZB); \ + pz=pz1+x1; \ + z=z1; \ + sz=sz1;\ + tz=tz1;\ + while (n>=(NB_INTERP-1)) { \ + {\ + float ss,tt;\ + ss=(sz * zinv);\ + tt=(tz * zinv);\ + s=(int) ss;\ + t=(int) tt;\ + dsdx= (int)( (dszdx - ss*fdzdx)*zinv );\ + dtdx= (int)( (dtzdx - tt*fdzdx)*zinv );\ + fz+=fndzdx;\ + zinv=1.0 / fz;\ + }\ + PUT_PIXEL(0); \ + PUT_PIXEL(1); \ + PUT_PIXEL(2); \ + PUT_PIXEL(3); \ + PUT_PIXEL(4); \ + PUT_PIXEL(5); \ + PUT_PIXEL(6); \ + PUT_PIXEL(7); \ + pz+=NB_INTERP; \ + pp=(PIXEL *)((char *)pp + NB_INTERP * PSZB);\ + n-=NB_INTERP; \ + sz+=ndszdx;\ + tz+=ndtzdx;\ + } \ + {\ + float ss,tt;\ + ss=(sz * zinv);\ + tt=(tz * zinv);\ + s=(int) ss;\ + t=(int) tt;\ + dsdx= (int)( (dszdx - ss*fdzdx)*zinv );\ + dtdx= (int)( (dtzdx - tt*fdzdx)*zinv );\ + }\ + while (n>=0) { \ + PUT_PIXEL(0); \ + pz+=1; \ + pp=(PIXEL *)((char *)pp + PSZB);\ + n-=1; \ + } \ +} + +#include "ztriangle.h" +} + +#endif + +#if 0 + +/* slow but exact version (only there for reference, incorrect for 24 + bits) */ + +void ZB_fillTriangleMappingPerspective(ZBuffer *zb, + ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2) +{ + PIXEL *texture; + +#define INTERP_Z +#define INTERP_STZ + +#define DRAW_INIT() \ +{ \ + texture=zb->current_texture; \ +} + +#define PUT_PIXEL(_a) \ +{ \ + float zinv; \ + int s,t; \ + zz=z >> ZB_POINT_Z_FRAC_BITS; \ + if (ZCMP(zz,pz[_a])) { \ + zinv= 1.0 / (float) z; \ + s= (int) (sz * zinv); \ + t= (int) (tz * zinv); \ + pp[_a]=texture[((t & 0x3FC00000) | s) >> 14]; \ + pz[_a]=zz; \ + } \ + z+=dzdx; \ + sz+=dszdx; \ + tz+=dtzdx; \ +} + +#include "ztriangle.h" +} + + +#endif diff --git a/3rdparty/tinygl-0.4-ugfx/src/ztriangle.h b/3rdparty/tinygl-0.4-ugfx/src/ztriangle.h new file mode 100644 index 00000000..b6142642 --- /dev/null +++ b/3rdparty/tinygl-0.4-ugfx/src/ztriangle.h @@ -0,0 +1,363 @@ +/* + * We draw a triangle with various interpolations + */ + +{ + ZBufferPoint *t,*pr1,*pr2,*l1,*l2; + float fdx1, fdx2, fdy1, fdy2, fz, d1, d2; + unsigned short *pz1; + PIXEL *pp1; + int part,update_left,update_right; + + int nb_lines,dx1,dy1,tmp,dx2,dy2; + + int error,derror; + int x1,dxdy_min,dxdy_max; +/* warning: x2 is multiplied by 2^16 */ + int x2,dx2dy2; + +#ifdef INTERP_Z + int z1,dzdx,dzdy,dzdl_min,dzdl_max; +#endif +#ifdef INTERP_RGB + int r1,drdx,drdy,drdl_min,drdl_max; + int g1,dgdx,dgdy,dgdl_min,dgdl_max; + int b1,dbdx,dbdy,dbdl_min,dbdl_max; +#endif +#ifdef INTERP_ST + int s1,dsdx,dsdy,dsdl_min,dsdl_max; + int t1,dtdx,dtdy,dtdl_min,dtdl_max; +#endif +#ifdef INTERP_STZ + float sz1,dszdx,dszdy,dszdl_min,dszdl_max; + float tz1,dtzdx,dtzdy,dtzdl_min,dtzdl_max; +#endif + + /* we sort the vertex with increasing y */ + if (p1->y < p0->y) { + t = p0; + p0 = p1; + p1 = t; + } + if (p2->y < p0->y) { + t = p2; + p2 = p1; + p1 = p0; + p0 = t; + } else if (p2->y < p1->y) { + t = p1; + p1 = p2; + p2 = t; + } + + /* we compute dXdx and dXdy for all interpolated values */ + + fdx1 = p1->x - p0->x; + fdy1 = p1->y - p0->y; + + fdx2 = p2->x - p0->x; + fdy2 = p2->y - p0->y; + + fz = fdx1 * fdy2 - fdx2 * fdy1; + if (fz == 0) + return; + fz = 1.0 / fz; + + fdx1 *= fz; + fdy1 *= fz; + fdx2 *= fz; + fdy2 *= fz; + +#ifdef INTERP_Z + d1 = p1->z - p0->z; + d2 = p2->z - p0->z; + dzdx = (int) (fdy2 * d1 - fdy1 * d2); + dzdy = (int) (fdx1 * d2 - fdx2 * d1); +#endif + +#ifdef INTERP_RGB + d1 = p1->r - p0->r; + d2 = p2->r - p0->r; + drdx = (int) (fdy2 * d1 - fdy1 * d2); + drdy = (int) (fdx1 * d2 - fdx2 * d1); + + d1 = p1->g - p0->g; + d2 = p2->g - p0->g; + dgdx = (int) (fdy2 * d1 - fdy1 * d2); + dgdy = (int) (fdx1 * d2 - fdx2 * d1); + + d1 = p1->b - p0->b; + d2 = p2->b - p0->b; + dbdx = (int) (fdy2 * d1 - fdy1 * d2); + dbdy = (int) (fdx1 * d2 - fdx2 * d1); + +#endif + +#ifdef INTERP_ST + d1 = p1->s - p0->s; + d2 = p2->s - p0->s; + dsdx = (int) (fdy2 * d1 - fdy1 * d2); + dsdy = (int) (fdx1 * d2 - fdx2 * d1); + + d1 = p1->t - p0->t; + d2 = p2->t - p0->t; + dtdx = (int) (fdy2 * d1 - fdy1 * d2); + dtdy = (int) (fdx1 * d2 - fdx2 * d1); +#endif + +#ifdef INTERP_STZ + { + float zz; + zz=(float) p0->z; + p0->sz= (float) p0->s * zz; + p0->tz= (float) p0->t * zz; + zz=(float) p1->z; + p1->sz= (float) p1->s * zz; + p1->tz= (float) p1->t * zz; + zz=(float) p2->z; + p2->sz= (float) p2->s * zz; + p2->tz= (float) p2->t * zz; + + d1 = p1->sz - p0->sz; + d2 = p2->sz - p0->sz; + dszdx = (fdy2 * d1 - fdy1 * d2); + dszdy = (fdx1 * d2 - fdx2 * d1); + + d1 = p1->tz - p0->tz; + d2 = p2->tz - p0->tz; + dtzdx = (fdy2 * d1 - fdy1 * d2); + dtzdy = (fdx1 * d2 - fdx2 * d1); + } +#endif + + /* screen coordinates */ + + pp1 = (PIXEL *) ((char *) zb->pbuf + zb->linesize * p0->y); + pz1 = zb->zbuf + p0->y * zb->xsize; + + DRAW_INIT(); + + for(part=0;part<2;part++) { + if (part == 0) { + if (fz > 0) { + update_left=1; + update_right=1; + l1=p0; + l2=p2; + pr1=p0; + pr2=p1; + } else { + update_left=1; + update_right=1; + l1=p0; + l2=p1; + pr1=p0; + pr2=p2; + } + nb_lines = p1->y - p0->y; + } else { + /* second part */ + if (fz > 0) { + update_left=0; + update_right=1; + pr1=p1; + pr2=p2; + } else { + update_left=1; + update_right=0; + l1=p1; + l2=p2; + } + nb_lines = p2->y - p1->y + 1; + } + + /* compute the values for the left edge */ + + if (update_left) { + dy1 = l2->y - l1->y; + dx1 = l2->x - l1->x; + if (dy1 > 0) + tmp = (dx1 << 16) / dy1; + else + tmp = 0; + x1 = l1->x; + error = 0; + derror = tmp & 0x0000ffff; + dxdy_min = tmp >> 16; + dxdy_max = dxdy_min + 1; + +#ifdef INTERP_Z + z1=l1->z; + dzdl_min=(dzdy + dzdx * dxdy_min); + dzdl_max=dzdl_min + dzdx; +#endif +#ifdef INTERP_RGB + r1=l1->r; + drdl_min=(drdy + drdx * dxdy_min); + drdl_max=drdl_min + drdx; + + g1=l1->g; + dgdl_min=(dgdy + dgdx * dxdy_min); + dgdl_max=dgdl_min + dgdx; + + b1=l1->b; + dbdl_min=(dbdy + dbdx * dxdy_min); + dbdl_max=dbdl_min + dbdx; +#endif +#ifdef INTERP_ST + s1=l1->s; + dsdl_min=(dsdy + dsdx * dxdy_min); + dsdl_max=dsdl_min + dsdx; + + t1=l1->t; + dtdl_min=(dtdy + dtdx * dxdy_min); + dtdl_max=dtdl_min + dtdx; +#endif +#ifdef INTERP_STZ + sz1=l1->sz; + dszdl_min=(dszdy + dszdx * dxdy_min); + dszdl_max=dszdl_min + dszdx; + + tz1=l1->tz; + dtzdl_min=(dtzdy + dtzdx * dxdy_min); + dtzdl_max=dtzdl_min + dtzdx; +#endif + } + + /* compute values for the right edge */ + + if (update_right) { + dx2 = (pr2->x - pr1->x); + dy2 = (pr2->y - pr1->y); + if (dy2>0) + dx2dy2 = ( dx2 << 16) / dy2; + else + dx2dy2 = 0; + x2 = pr1->x << 16; + } + + /* we draw all the scan line of the part */ + + while (nb_lines>0) { + nb_lines--; +#ifndef DRAW_LINE + /* generic draw line */ + { + register PIXEL *pp; + register int n; +#ifdef INTERP_Z + register unsigned short *pz; + register unsigned int z,zz; +#endif +#ifdef INTERP_RGB + register unsigned int or1,og1,ob1; +#endif +#ifdef INTERP_ST + register unsigned int s,t; +#endif +#ifdef INTERP_STZ + float sz,tz; +#endif + + n=(x2 >> 16) - x1; + pp=(PIXEL *)((char *)pp1 + x1 * PSZB); +#ifdef INTERP_Z + pz=pz1+x1; + z=z1; +#endif +#ifdef INTERP_RGB + or1 = r1; + og1 = g1; + ob1 = b1; +#endif +#ifdef INTERP_ST + s=s1; + t=t1; +#endif +#ifdef INTERP_STZ + sz=sz1; + tz=tz1; +#endif + while (n>=3) { + PUT_PIXEL(0); + PUT_PIXEL(1); + PUT_PIXEL(2); + PUT_PIXEL(3); +#ifdef INTERP_Z + pz+=4; +#endif + pp=(PIXEL *)((char *)pp + 4 * PSZB); + n-=4; + } + while (n>=0) { + PUT_PIXEL(0); +#ifdef INTERP_Z + pz+=1; +#endif + pp=(PIXEL *)((char *)pp + PSZB); + n-=1; + } + } +#else + DRAW_LINE(); +#endif + + /* left edge */ + error+=derror; + if (error > 0) { + error-=0x10000; + x1+=dxdy_max; +#ifdef INTERP_Z + z1+=dzdl_max; +#endif +#ifdef INTERP_RGB + r1+=drdl_max; + g1+=dgdl_max; + b1+=dbdl_max; +#endif +#ifdef INTERP_ST + s1+=dsdl_max; + t1+=dtdl_max; +#endif +#ifdef INTERP_STZ + sz1+=dszdl_max; + tz1+=dtzdl_max; +#endif + } else { + x1+=dxdy_min; +#ifdef INTERP_Z + z1+=dzdl_min; +#endif +#ifdef INTERP_RGB + r1+=drdl_min; + g1+=dgdl_min; + b1+=dbdl_min; +#endif +#ifdef INTERP_ST + s1+=dsdl_min; + t1+=dtdl_min; +#endif +#ifdef INTERP_STZ + sz1+=dszdl_min; + tz1+=dtzdl_min; +#endif + } + + /* right edge */ + x2+=dx2dy2; + + /* screen coordinates */ + pp1=(PIXEL *)((char *)pp1 + zb->linesize); + pz1+=zb->xsize; + } + } +} + +#undef INTERP_Z +#undef INTERP_RGB +#undef INTERP_ST +#undef INTERP_STZ + +#undef DRAW_INIT +#undef DRAW_LINE +#undef PUT_PIXEL diff --git a/demos/modules/gwin/gl3d/demo.mk b/demos/modules/gwin/gl3d/demo.mk new file mode 100644 index 00000000..2f20deb6 --- /dev/null +++ b/demos/modules/gwin/gl3d/demo.mk @@ -0,0 +1,3 @@ +DEMODIR = $(GFXLIB)/demos/modules/gwin/gl3d +GFXINC += $(DEMODIR) +GFXSRC += $(DEMODIR)/main.c diff --git a/demos/modules/gwin/gl3d/gfxconf.h b/demos/modules/gwin/gl3d/gfxconf.h new file mode 100644 index 00000000..d0375a19 --- /dev/null +++ b/demos/modules/gwin/gl3d/gfxconf.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2012, 2013, Joel Bodenmann aka Tectu + * Copyright (c) 2012, 2013, Andrew Hannam aka inmarket + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _GFXCONF_H +#define _GFXCONF_H + +/* The operating system to use. One of these must be defined - preferably in your Makefile */ +//#define GFX_USE_OS_CHIBIOS FALSE +//#define GFX_USE_OS_WIN32 FALSE +//#define GFX_USE_OS_LINUX FALSE +//#define GFX_USE_OS_OSX FALSE + +/* GFX sub-systems to turn on */ +#define GFX_USE_GDISP TRUE +#define GFX_USE_GWIN TRUE + +/* Features for the GDISP sub-system. */ +#define GDISP_NEED_VALIDATION TRUE +#define GDISP_NEED_CLIP TRUE + +/* Features for the GWIN subsystem. */ +#define GWIN_NEED_GL3D TRUE + +#endif /* _GFXCONF_H */ + diff --git a/demos/modules/gwin/gl3d/main.c b/demos/modules/gwin/gl3d/main.c new file mode 100644 index 00000000..f93f37ec --- /dev/null +++ b/demos/modules/gwin/gl3d/main.c @@ -0,0 +1,179 @@ +/* + * Copyright (c) 2012, 2013, Joel Bodenmann aka Tectu + * Copyright (c) 2012, 2013, Andrew Hannam aka inmarket + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "gfx.h" + +/* The handles for our two Windows */ +GHandle gh; + +static GLfloat Xrot, Xstep; +static GLfloat Yrot, Ystep; +static GLfloat Zrot, Zstep; +static GLfloat Step = 5.0; +static GLfloat Scale = 1.0; +static GLuint Object; + +static GLuint make_object( void ) +{ + GLuint list; + + list = glGenLists( 1 ); + + glNewList( list, GL_COMPILE ); + + glBegin( GL_LINE_LOOP ); + glColor3f( 1.0, 1.0, 1.0 ); + glVertex3f( 1.0, 0.5, -0.4 ); + glColor3f( 1.0, 0.0, 0.0 ); + glVertex3f( 1.0, -0.5, -0.4 ); + glColor3f( 0.0, 1.0, 0.0 ); + glVertex3f( -1.0, -0.5, -0.4 ); + glColor3f( 0.0, 0.0, 1.0 ); + glVertex3f( -1.0, 0.5, -0.4 ); + glEnd(); + + glColor3f( 1.0, 1.0, 1.0 ); + + glBegin( GL_LINE_LOOP ); + glVertex3f( 1.0, 0.5, 0.4 ); + glVertex3f( 1.0, -0.5, 0.4 ); + glVertex3f( -1.0, -0.5, 0.4 ); + glVertex3f( -1.0, 0.5, 0.4 ); + glEnd(); + + glBegin( GL_LINES ); + glVertex3f( 1.0, 0.5, -0.4 ); glVertex3f( 1.0, 0.5, 0.4 ); + glVertex3f( 1.0, -0.5, -0.4 ); glVertex3f( 1.0, -0.5, 0.4 ); + glVertex3f( -1.0, -0.5, -0.4 ); glVertex3f( -1.0, -0.5, 0.4 ); + glVertex3f( -1.0, 0.5, -0.4 ); glVertex3f( -1.0, 0.5, 0.4 ); + glEnd(); + + + glEndList(); + + return list; +} + +static void draw( void ) +{ + glClear( GL_COLOR_BUFFER_BIT ); + + glPushMatrix(); + + glTranslatef( 0.0, 0.0, -10.0 ); + glScalef( Scale, Scale, Scale ); + if (Xstep) { + glRotatef( Xrot, 1.0, 0.0, 0.0 ); + } + else if (Ystep) { + glRotatef( Yrot, 0.0, 1.0, 0.0 ); + } + else { + glRotatef( Zrot, 0.0, 0.0, 1.0 ); + } + + glCallList( Object ); + + glPopMatrix(); + + glFlush(); + gwinRedraw(gh); +} + + +static void idle( void ) +{ + Xrot += Xstep; + Yrot += Ystep; + Zrot += Zstep; + + if (Xrot>=360.0) { + Xrot = Xstep = 0.0; + Ystep = Step; + } + else if (Yrot>=360.0) { + Yrot = Ystep = 0.0; + Zstep = Step; + } + else if (Zrot>=360.0) { + Zrot = Zstep = 0.0; + Xstep = Step; + } + draw(); +} + +int main(void) { + /* Initialize and clear the display */ + gfxInit(); + gdispClear(White); + + /* Create the 3D window */ + { + GWindowInit wi; + + gwinClearInit(&wi); + wi.show = TRUE; wi.x = 20; wi.y = 10; wi.width = 200; wi.height = 150; + gh = gwinGL3DCreate(0, &wi); + } + + /* Set fore- and background colors */ + gwinSetColor(gh, White); + gwinSetBgColor(gh, Blue); + + /* Clear the window */ + gwinClear(gh); + + /* Init the 3D stuff */ + glViewport(0, 0, (GLint)gwinGetWidth(gh), (GLint)gwinGetHeight(gh)); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 15.0 ); + glMatrixMode(GL_MODELVIEW); + + Object = make_object(); + glCullFace( GL_BACK ); + // glEnable( GL_CULL_FACE ); + glDisable( GL_DITHER ); + glShadeModel( GL_FLAT ); + // glEnable( GL_DEPTH_TEST ); + Xrot = Yrot = Zrot = 0.0; + Xstep = Step; + Ystep = Zstep = 0.0; + + + while(TRUE) { + + // rate control + gfxSleepMilliseconds(10); + + // move and redraw + idle(); + } +} + diff --git a/gfxconf.example.h b/gfxconf.example.h index 2abcf0b4..c163986c 100644 --- a/gfxconf.example.h +++ b/gfxconf.example.h @@ -153,6 +153,7 @@ // #define GWIN_CONSOLE_USE_BASESTREAM FALSE // #define GWIN_CONSOLE_USE_FLOAT FALSE //#define GWIN_NEED_GRAPH FALSE +//#define GWIN_NEED_GL3D FALSE //#define GWIN_NEED_WIDGET FALSE // #define GWIN_NEED_LABEL FALSE diff --git a/src/gwin/gwin_gl3d.c b/src/gwin/gwin_gl3d.c new file mode 100644 index 00000000..e04875c0 --- /dev/null +++ b/src/gwin/gwin_gl3d.c @@ -0,0 +1,171 @@ +/* + * This file is subject to the terms of the GFX License. If a copy of + * the license was not distributed with this file, you can obtain one at: + * + * http://ugfx.org/license.html + */ + +/** + * @file src/gwin/gwin_gl3d.c + * @brief GWIN sub-system button code + */ + +#include "gfx.h" + +#if GFX_USE_GWIN && GWIN_NEED_GL3D + +#if GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB565 + #error "GWIN: GL3D only support GDISP_PIXELFORMAT_RGB565 color format (TinyGL limitation)" +#endif + +#include "src/gwin/class_gwin.h" + +#include "3rdparty/tinygl-0.4-ugfx/src/zgl.h" + +// Forward definitions +static void gl3dDestroy(GWindowObject *gh); +static void gl3dRedraw(GWindowObject *gh); +static int gl3dResizeGLViewport(GLContext *c, int *xsize_ptr, int *ysize_ptr); + +static const gwinVMT gl3dVMT = { + "GL3D", // The classname + sizeof(GGL3DObject), // The object size + gl3dDestroy, // The destroy routine + gl3dRedraw, // The redraw routine + 0, // The after-clear routine +}; + +static bool_t haveGLwindow = FALSE; + +GHandle gwinGGL3DCreate(GDisplay *g, GGL3DObject *gl, const GWindowInit *pInit) { + ZBuffer * zb; + GLContext * glcxt; + + // Only one GL3D window allowed at a time (TinyGL limitation) + if (haveGLwindow) + return 0; + + if (!(gl = (GGL3DObject *)_gwindowCreate(g, &gl->g, pInit, &gl3dVMT, 0))) + return 0; + + // Must be a multiple of 4 bytes + gl->g.width &= ~3; + gl->g.height &= ~3; + + zb = ZB_open(gl->g.width, gl->g.height, ZB_MODE_5R6G5B, 0, NULL, NULL, NULL); + if (!zb) { + if ((gl->g.flags & GWIN_FLG_DYNAMIC)) + gfxFree(gl); + return 0; + } + + /* initialisation of the TinyGL interpreter */ + glInit(zb); + gl->glcxt = glcxt = gl_get_context(); + glcxt->opaque = gl; + glcxt->gl_resize_viewport = gl3dResizeGLViewport; + + /* set the viewport : we force a call to the viewport resize routine */ + glcxt->viewport.xsize=-1; + glcxt->viewport.ysize=-1; + + glViewport(0, 0, gl->g.width, gl->g.height); + + haveGLwindow = TRUE; + gwinSetVisible((GHandle)gl, pInit->show); + return (GHandle)gl; +} + +static void gl3dDestroy(GWindowObject *gh) { + (void) gh; + glClose(); + haveGLwindow = FALSE; +} + +static void gl3dRedraw(GWindowObject *gh) { + ZBuffer * zb; + + zb = ((GGL3DObject *)gh)->glcxt->zb; + gdispGBlitArea(gh->display, gh->x, gh->y, zb->xsize, zb->ysize, 0, 0, zb->linesize/sizeof(color_t), (const pixel_t *)zb->pbuf); +} + +static int gl3dResizeGLViewport(GLContext *c, int *xsize_ptr, int *ysize_ptr) { + int cx, cy; + + cx = *xsize_ptr; + cy = *ysize_ptr; + + // We ensure that cx and cy are multiples of 4 for the zbuffer. TODO: find a better solution + cx &= ~3; + cy &= ~3; + + if (cx <= 0 || cy <= 0) + return -1; + + *xsize_ptr = cx; + *ysize_ptr = cy; + + // Resize the GWIN??? + + // Resize the Z buffer + ZB_resize(c->zb, NULL, cx, cy); + return 0; +} + +/** + * TinyGL support routines + */ + +#include + +#define NO_CLIBRARY + +void tgl_warning(const char *format, ...) { (void)format; } +void tgl_trace(const char *format, ...) { (void)format; } +void tgl_fixme(const char *format, ...) { (void)format; } +void gl_fatal_error(char *format, ...) { gfxHalt(format); } +void gl_assert(int test) { if (!test) gfxHalt("TinyGL Assert"); } + +void gl_free(void *p) { gfxFree(p); } +void *gl_malloc(int size) { return gfxAlloc(size); } + +void *gl_zalloc(int size) { + void *p; + + p = gfxAlloc(size); + if (p) + memset(p, 0, size); + return p; +} + + +/** + * Pre-load TinyGL headers + */ + +/** + * TinyGL wrapper code + */ + +#include "3rdparty/tinygl-0.4-ugfx/src/api.c" +#include "3rdparty/tinygl-0.4-ugfx/src/list.c" +#include "3rdparty/tinygl-0.4-ugfx/src/vertex.c" +#include "3rdparty/tinygl-0.4-ugfx/src/init.c" +#include "3rdparty/tinygl-0.4-ugfx/src/matrix.c" +#include "3rdparty/tinygl-0.4-ugfx/src/texture.c" +#include "3rdparty/tinygl-0.4-ugfx/src/misc.c" +#include "3rdparty/tinygl-0.4-ugfx/src/clear.c" +#include "3rdparty/tinygl-0.4-ugfx/src/light.c" +#include "3rdparty/tinygl-0.4-ugfx/src/clip.c" +#include "3rdparty/tinygl-0.4-ugfx/src/select.c" +#include "3rdparty/tinygl-0.4-ugfx/src/get.c" +#include "3rdparty/tinygl-0.4-ugfx/src/zbuffer.c" +#include "3rdparty/tinygl-0.4-ugfx/src/zline.c" +#include "3rdparty/tinygl-0.4-ugfx/src/zdither.c" +#include "3rdparty/tinygl-0.4-ugfx/src/ztriangle.c" +#include "3rdparty/tinygl-0.4-ugfx/src/zmath.c" +#include "3rdparty/tinygl-0.4-ugfx/src/image_util.c" +#include "3rdparty/tinygl-0.4-ugfx/src/arrays.c" +#include "3rdparty/tinygl-0.4-ugfx/src/specbuf.c" + +#endif /* GFX_USE_GWIN && GWIN_NEED_GL3D */ diff --git a/src/gwin/gwin_gl3d.h b/src/gwin/gwin_gl3d.h new file mode 100644 index 00000000..ca3edf6f --- /dev/null +++ b/src/gwin/gwin_gl3d.h @@ -0,0 +1,70 @@ +/* + * This file is subject to the terms of the GFX License. If a copy of + * the license was not distributed with this file, you can obtain one at: + * + * http://ugfx.org/license.html + */ + +/** + * @file src/gwin/gwin_gl3d.h + * @brief GWIN 3D module header file + * + * @defgroup 3D 3D + * @ingroup Windows + * + * @details 3D GWIN window based on OpenGL (or more exactly Tiny GL) + * @pre GFX_USE_GWIN must be set to TRUE in your gfxconf.h + * @pre GWIN_NEED_GL3D must be set to TRUE in your gfxconf.h + * + * @{ + */ + +#ifndef _GWIN_GL3D_H +#define _GWIN_GL3D_H + +/* This file is included within "gwin/gwin.h" */ + + +// A gl3d window +typedef struct GGL3DObject { + GWindowObject g; + struct GLContext * glcxt; + } GGL3DObject; + +/*===========================================================================*/ +/* External declarations. */ +/*===========================================================================*/ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief Create a gl3d window. + * @return NULL if there is no resultant drawing area, otherwise a window handle. + * + * @param[in] g The GDisplay to display this window on + * @param[in] gg The GGL3DObject structure to initialise. If this is NULL the structure is dynamically allocated. + * @param[in] pInit The initialization parameters to use + * + * @note The drawing color and the background color get set to the current defaults. If you haven't called + * @p gwinSetDefaultColor() or @p gwinSetDefaultBgColor() then these are White and Black respectively. + * @note The font gets set to the current default font. If you haven't called @p gwinSetDefaultFont() then there + * is no default font and text drawing operations will no nothing. + * @note The dimensions and position may be changed to fit on the real screen. + * + * @api + */ +GHandle gwinGGL3DCreate(GDisplay *g, GGL3DObject *gg, const GWindowInit *pInit); +#define gwinGL3DCreate(gg, pInit) gwinGGL3DCreate(GDISP, gg, pInit) + +/* Include the gl interface */ +#include "3rdparty/tinygl-0.4-ugfx/include/GL/gl.h" + +#ifdef __cplusplus +} +#endif + +#endif /* _GWIN_GL3D_H */ +/** @} */ + diff --git a/src/gwin/sys_defs.h b/src/gwin/sys_defs.h index 4b103d11..7823eafe 100644 --- a/src/gwin/sys_defs.h +++ b/src/gwin/sys_defs.h @@ -962,14 +962,15 @@ extern "C" { #if GWIN_NEED_CONSOLE || defined(__DOXYGEN__) #include "src/gwin/console.h" #endif - #if GWIN_NEED_GRAPH || defined(__DOXYGEN__) #include "src/gwin/graph.h" #endif - #if GWIN_NEED_IMAGE || defined(__DOXYGEN__) #include "src/gwin/gimage.h" #endif + #if GWIN_NEED_GL3D || defined(__DOXYGEN__) + #include "src/gwin/gwin_gl3d.h" + #endif #endif /* GFX_USE_GWIN */ diff --git a/src/gwin/sys_make.mk b/src/gwin/sys_make.mk index 95a2ba84..f905f8d3 100644 --- a/src/gwin/sys_make.mk +++ b/src/gwin/sys_make.mk @@ -13,4 +13,6 @@ GFXSRC += $(GFXLIB)/src/gwin/gwin.c \ $(GFXLIB)/src/gwin/progressbar.c \ $(GFXLIB)/src/gwin/gcontainer.c \ $(GFXLIB)/src/gwin/frame.c \ - + $(GFXLIB)/src/gwin/gwin_gl3d.c \ + +GFXINC += $(GFXLIB)/3rdparty/tinygl-0.4-ugfx/include diff --git a/src/gwin/sys_options.h b/src/gwin/sys_options.h index d5240556..199cad5b 100644 --- a/src/gwin/sys_options.h +++ b/src/gwin/sys_options.h @@ -72,6 +72,13 @@ #ifndef GWIN_NEED_GRAPH #define GWIN_NEED_GRAPH FALSE #endif + /** + * @brief Should gl3d functions be included. + * @details Defaults to FALSE + */ + #ifndef GWIN_NEED_GL3D + #define GWIN_NEED_GL3D FALSE + #endif /** * @brief Should button functions be included. * @details Defaults to FALSE