[commit] r2355 - add generated B3D and Rome plugins
Locked
 
|
Author: piumarta Date: 2011-01-23 01:41:21 -0800 (Sun, 23 Jan 2011) New Revision: 2355 Added: trunk/platforms/unix/src/plugins/RomePlugin/ trunk/platforms/unix/src/plugins/RomePlugin/RomePlugin.c trunk/platforms/unix/src/plugins/Squeak3D/ trunk/platforms/unix/src/plugins/Squeak3D/Squeak3D.c Modified: trunk/platforms/unix/src/plugins.ext trunk/platforms/unix/src/plugins/B3DAcceleratorPlugin/B3DAcceleratorPlugin.c trunk/platforms/unix/src/vm/intplugins/ADPCMCodecPlugin/ADPCMCodecPlugin.c trunk/platforms/unix/src/vm/intplugins/SoundGenerationPlugin/SoundGenerationPlugin.c trunk/platforms/unix/src/vm/sqNamedPrims.h Log: add generated B3D and Rome plugins Modified: trunk/platforms/unix/src/plugins/B3DAcceleratorPlugin/B3DAcceleratorPlugin.c =================================================================== --- trunk/platforms/unix/src/plugins/B3DAcceleratorPlugin/B3DAcceleratorPlugin.c 2011-01-23 07:34:41 UTC (rev 2354) +++ trunk/platforms/unix/src/plugins/B3DAcceleratorPlugin/B3DAcceleratorPlugin.c 2011-01-23 09:41:21 UTC (rev 2355) @@ -1,4 +1,4 @@ -/* Automatically generated from Squeak on 23 January 2011 3:55:50 pm +/* Automatically generated from Squeak on 23 January 2011 6:31:52 pm by VMMaker 4.4.7 */ Added: trunk/platforms/unix/src/plugins/RomePlugin/RomePlugin.c =================================================================== --- trunk/platforms/unix/src/plugins/RomePlugin/RomePlugin.c (rev 0) +++ trunk/platforms/unix/src/plugins/RomePlugin/RomePlugin.c 2011-01-23 09:41:21 UTC (rev 2355) @@ -0,0 +1,3601 @@ +/* Automatically generated from Squeak on 23 January 2011 6:31:55 pm + by VMMaker 4.4.7 + */ + +#include <math.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> + +/* Default EXPORT macro that does nothing (see comment in sq.h): */ +#define EXPORT(returnType) returnType + +/* Do not include the entire sq.h file but just those parts needed. */ +/* The virtual machine proxy definition */ +#include "sqVirtualMachine.h" +/* Configuration options */ +#include "sqConfig.h" +/* Platform specific definitions */ +#include "sqPlatformSpecific.h" + +#define true 1 +#define false 0 +#define null 0 /* using 'null' because nil is predefined in Think C */ +#ifdef SQUEAK_BUILTIN_PLUGIN +#undef EXPORT +// was #undef EXPORT(returnType) but screws NorCroft cc +#define EXPORT(returnType) static returnType +#endif +#include <cairo.h> +#include <cairo-ft.h> +#include <pango/pangocairo.h> +#include "SurfacePlugin.h" +#define NUM_OF(array) (sizeof (array) / sizeof *(array)) +#define lastIndex(array) (NUM_OF(array) - 1) +#define degrees(a) (a * 3.141592653589793 / 180.0) + +#define log(msg) fprintf(stderr, "Squeak-Rome: " msg "\n") +#define logwith(msg, a) fprintf(stderr, "Squeak-Rome: " msg "\n", a) +#define logwithwith(msg, a, b) fprintf(stderr, "Squeak-Rome: " msg "\n", a, b) +#define logwithwithwith(msg, a, b, c) fprintf(stderr, "Squeak-Rome: " msg "\n", a, b, c) +#define logwithwithwithwith(msg, a, b, c, d) fprintf(stderr, "Squeak-Rome: " msg "\n", a, b, c, d) +#define logwithwithwithwithwith(msg, a, b, c, d, e) fprintf(stderr, "Squeak-Rome: " msg "\n", a, b, c, d, e) + +#define primFail interpreterProxy->primitiveFail() +#define fail(msg) log(msg "!"); primFail +#define failwith(msg, a) logwith(msg "!", a); primFail +#define failwithwith(msg, a, b) logwithwith(msg "!", a, b); primFail + + +#include "sqMemoryAccess.h" + + +/*** Constants ***/ +#define CairoExtendRepeat CAIRO_EXTEND_REPEAT +#define CairoOperatorSource CAIRO_OPERATOR_SOURCE +#define CanvasFlagFill 256 +#define CanvasFlagStroke 255 +#define CanvasFlagsIndex 2 +#define CanvasHandleIndex 0 +#define CanvasInstSize 8 +#define CanvasStrokeColorIndex 3 +#define CanvasTargetIndex 1 +#define FormBitsIndex 0 +#define FormDepthIndex 3 +#define FormHeightIndex 2 +#define FormInstSize 5 +#define FormWidthIndex 1 +#define PluginVersion 39 +#define TextLineBottomIndex 3 +#define TextLineEndIndex 5 +#define TextLineInternalSpaceIndex 6 +#define TextLineLeftIndex 0 +#define TextLinePaddingWidthIndex 7 +#define TextLineRightIndex 1 +#define TextLineStartIndex 4 +#define TextLineTopIndex 2 + +/*** Function Prototypes ***/ +static sqInt addAlignmentinto(sqInt attrArrayOop, PangoAttrList *pangoAttrList); +static sqInt addColorinto(sqInt attrArrayOop, PangoAttrList *pangoAttrList); +static void addColorStopTooffsetrgbalpha(cairo_pattern_t*pattern, sqInt intOffset, sqInt rgb, sqInt alpha); +static sqInt addDefaultInto(PangoAttrList *pangoAttrList); +static sqInt addEmphasisinto(sqInt attrArrayOop, PangoAttrList *pangoAttrList); +static sqInt addFontinto(sqInt attrArrayOop, PangoAttrList *pangoAttrList); +static sqInt addLanguageinto(sqInt attrArrayOop, PangoAttrList *pangoAttrList); +static sqInt addSelectionAtpixelwith(PangoRectangle *rect, unsigned int c, cairo_t*context); +static sqInt addSelectionFromtopixelinto(sqInt start, sqInt end, unsigned int c, PangoAttrList *pangoAttrList); +static cairo_t* contextFrom(sqInt canvasOop); +static sqInt createContextFor(sqInt canvasOop); +static sqInt createSurfaceFor(sqInt formOop); +static sqInt destroyContextFor(sqInt canvasOop); +static sqInt destroySurface(sqInt surfaceID); +static void fillOrStrokefrom(cairo_t*context, sqInt canvasOop); +static cairo_surface_t* findSurface(sqInt surfaceID); +static VirtualMachine * getInterpreter(void); +#pragma export on +EXPORT(const char*) getModuleName(void); +#pragma export off +static sqInt getSurfaceFormatgetWgetHgetDgetMsb(cairo_surface_t *surfaceHandle, int*wReturn, int*hReturn, int*dReturn, int*mReturn); +static sqInt halt(void); +#pragma export on +EXPORT(sqInt) initialiseModule(void); +#pragma export off +static sqInt leadingCharOf(unsigned int value); +static sqInt loadSurfacePlugin(void); +static unsigned char* lockSurfacegetPitchxywh(cairo_surface_t*surfaceHandle, int*pitchReturn, sqInt x, sqInt y, sqInt w, sqInt h); +#pragma export on +EXPORT(sqInt) moduleUnloaded(char *aModuleName); +#pragma export off +static sqInt msg(char *s); +static void polyPathfrom(cairo_t*context, sqInt pointsOop); +#pragma export on +EXPORT(sqInt) primitivePangoBlockAtIndex(void); +EXPORT(sqInt) primitiveClear(void); +EXPORT(sqInt) primitiveClipRectangleLeftRightTopBottom(void); +EXPORT(sqInt) primitiveClose(void); +EXPORT(sqInt) primitivePangoComposeString(void); +EXPORT(sqInt) primitivePangoComposeString2(void); +EXPORT(sqInt) primitiveCreateFormHandle(void); +EXPORT(sqInt) primitiveDestroyFormHandle(void); +EXPORT(sqInt) primitiveDrawArcRadiusXYFromTo(void); +EXPORT(sqInt) primitiveDrawCurveFromXYviaXYandXYtoXY(void); +EXPORT(sqInt) primitiveDrawCurveFromXYviaXYtoXY(void); +EXPORT(sqInt) primitiveDrawGeneralBezierShape(void); +EXPORT(sqInt) primitiveDrawImageSrcLRTBDestLRTB(void); +EXPORT(sqInt) primitiveDrawLineFromXYtoXY(void); +EXPORT(sqInt) primitiveDrawOvalLeftRightTopBottom(void); +EXPORT(sqInt) primitiveDrawPolygon(void); +EXPORT(sqInt) primitiveDrawPolyline(void); +EXPORT(sqInt) primitiveDrawRectangleLeftRightTopBottom(void); +EXPORT(sqInt) primitiveDrawRoundRectLeftRightTopBottomRadiusCorner(void); +EXPORT(sqInt) primitiveDrawZeroTerminatedUtf8StringXY(void); +EXPORT(sqInt) primitiveFillBitmapOriginXYdirectionXYnormalXYRepeatImage(void); +EXPORT(sqInt) primitiveFillColorAlpha(void); +EXPORT(sqInt) primitiveFillLinearOriginXYdirectionXYcolorStops(void); +EXPORT(sqInt) primitiveFillRadialOriginXYdirectionXYnormalXYcolorStops(void); +EXPORT(sqInt) primitiveFontFace(void); +EXPORT(sqInt) primitiveFontSize(void); +EXPORT(sqInt) primitiveGetLineWidth(void); +EXPORT(sqInt) primitivePangoFontDescriptionIndex(void); +EXPORT(sqInt) primitiveGetTransform(void); +EXPORT(sqInt) primitivePangoIndexAtPoint(void); +EXPORT(sqInt) primitiveLanguageAttributes(void); +EXPORT(sqInt) primitiveOpen(void); +EXPORT(sqInt) primitivePangoIsAvailable(void); +EXPORT(sqInt) primitivePluginVersion(void); +EXPORT(sqInt) primitiveRestoreState(void); +EXPORT(sqInt) primitiveRotateBy(void); +EXPORT(sqInt) primitiveSaveState(void); +EXPORT(sqInt) primitiveScaleBy(void); +EXPORT(sqInt) primitiveSetLineWidth(void); +EXPORT(sqInt) primitiveSetTransform(void); +EXPORT(sqInt) primitivePangoShowString(void); +EXPORT(sqInt) primitiveShowZeroTerminatedUtf8StringXY(void); +EXPORT(sqInt) primitiveStencilImageSrcLRTBDestLRTB(void); +EXPORT(sqInt) primitiveTransformBy(void); +EXPORT(sqInt) primitiveTranslateBy(void); +EXPORT(sqInt) primitiveUTF8StringWith2Indexes(void); +EXPORT(sqInt) primitiveUTF8StringWithIndex(void); +#pragma export off +static sqInt putCharintoat(sqInt c, unsigned char*utf8String, sqInt utf8Index); +static sqInt registerSurface(cairo_surface_t*surfaceHandle); +#pragma export on +EXPORT(sqInt) setInterpreter(struct VirtualMachine*anInterpreter); +#pragma export off +static void setSourcergbalpha(cairo_t*context, sqInt rgb, sqInt alpha); +static sqInt showSurfacexywh(cairo_surface_t *surfaceHandle, sqInt x, sqInt y, sqInt w, sqInt h); +#pragma export on +EXPORT(sqInt) shutdownModule(void); +#pragma export off +static sqInt sqAssert(sqInt aBool); +static sqInt sqCharCountInfromto(unsigned char* aString, sqInt from, sqInt to); +static void strokefrom(cairo_t*context, sqInt canvasOop); +static cairo_surface_t* surfaceFrom(sqInt formOop); +static sqInt translateSqAttrsToPangoAttrsinto(sqInt sqAttrsArrayOop, PangoAttrList *pangoAttrList); +static sqInt unlockSurfacexywh(cairo_surface_t*surfaceHandle, sqInt x, sqInt y, sqInt w, sqInt h); +static sqInt unregisterSurface(sqInt surfaceID); +static sqInt utf8CountFor(unsigned int value); +/*** Variables ***/ +static cairo_t* contexts[64]; +static PangoFontDescription *defaultFontDescription; +static fn_ioFindSurface findSurfaceFn; +static PangoFontDescription *fontDescriptions[256]; +static int formatToDepth[] = { +32, 32, 8, 1, 16}; + +#ifdef SQUEAK_BUILTIN_PLUGIN +extern +#endif +struct VirtualMachine* interpreterProxy; +static sqInt maxSurfaceID; +static const char *moduleName = +#ifdef SQUEAK_BUILTIN_PLUGIN + "RomePlugin Aeneas.39 23 January 2011 (i)" +#else + "RomePlugin Aeneas.39 23 January 2011 (e)" +#endif +; +static fn_ioRegisterSurface registerSurfaceFn; +static sqSurfaceDispatch surfaceDispatch = { + 1, + 0, + (fn_getSurfaceFormat) getSurfaceFormatgetWgetHgetDgetMsb, + (fn_lockSurface) lockSurfacegetPitchxywh, + (fn_unlockSurface) unlockSurfacexywh, + (fn_showSurface) showSurfacexywh +}; +static fn_ioUnregisterSurface unregisterSurfaceFn; +static int utf8Headers[] = { +0, 192, 224, 240, 248, 252, 254, 255}; + + +static sqInt addAlignmentinto(sqInt attrArrayOop, PangoAttrList *pangoAttrList) { + sqInt start; + sqInt alignment; + int pangoAlignment; + sqInt end; + sqInt *attrArray; + + attrArray = interpreterProxy->firstIndexableField(attrArrayOop); + start = ((attrArray[1]) >> 1); + end = ((attrArray[2]) >> 1); + alignment = ((attrArray[3]) >> 1); + if (alignment == 0) { + pangoAlignment = PANGO_ALIGN_LEFT; + } + if (alignment == 1) { + pangoAlignment = PANGO_ALIGN_RIGHT; + } + if (alignment == 2) { + pangoAlignment = PANGO_ALIGN_CENTER; + } + if (alignment == 3) { + null; + } +} + +static sqInt addColorinto(sqInt attrArrayOop, PangoAttrList *pangoAttrList) { + sqInt start; + sqInt r; + sqInt b; + PangoAttribute *pangoAttr; + sqInt end; + sqInt g; + sqInt alpha; + sqInt *attrArray; + unsigned int c; + + attrArray = interpreterProxy->firstIndexableField(attrArrayOop); + start = ((attrArray[1]) >> 1); + end = ((attrArray[2]) >> 1); + + /* self log: 'color: %u' with: c. */ + + c = interpreterProxy->positive32BitValueOf(attrArray[3]); + alpha = ((usqInt) (c && 4278190080U)) >> 24; + r = ((usqInt) (c & 16711680)) >> 16; + g = ((usqInt) (c & 65280)) >> 8; + b = c & 255; + if (!(r == 0)) { + r = r * 257; + } + if (!(g == 0)) { + g = g * 257; + } + if (!(b == 0)) { + b = b * 257; + } + pangoAttr = pango_attr_foreground_new(r, g, b); + pangoAttr->start_index = start; + pangoAttr->end_index = end; + pango_attr_list_change(pangoAttrList, pangoAttr); +} + +static void addColorStopTooffsetrgbalpha(cairo_pattern_t*pattern, sqInt intOffset, sqInt rgb, sqInt alpha) { + sqInt b; + sqInt r; + sqInt g; + + r = (((usqInt) rgb) >> 20) & 1023; + g = (((usqInt) rgb) >> 10) & 1023; + b = (((usqInt) rgb) >> 0) & 1023; + if (alpha == 255) { + cairo_pattern_add_color_stop_rgb(pattern, intOffset / 65536.0, r / 1023.0, g / 1023.0, b / 1023.0); + } else { + cairo_pattern_add_color_stop_rgba(pattern, intOffset / 65536.0, r / 1023.0, g / 1023.0, b / 1023.0, alpha / 255.0); + } +} + +static sqInt addDefaultInto(PangoAttrList *pangoAttrList) { + PangoAttribute *pangoAttr; + PangoLanguage *lang; + + pangoAttr = pango_attr_foreground_new(0, 0, 1); + pangoAttr->start_index = 0; + pangoAttr->end_index = 0x7fffffff; + pango_attr_list_insert(pangoAttrList, pangoAttr); + pangoAttr = pango_attr_font_desc_new(defaultFontDescription); + pangoAttr->start_index = 0; + pangoAttr->end_index = 0x7fffffff; + pango_attr_list_insert(pangoAttrList, pangoAttr); + lang = pango_language_from_string("en-US"); + pangoAttr = pango_attr_language_new(lang); + pangoAttr->start_index = 0; + pangoAttr->end_index = 0x7fffffff; + pango_attr_list_insert(pangoAttrList, pangoAttr); +} + +static sqInt addEmphasisinto(sqInt attrArrayOop, PangoAttrList *pangoAttrList) { + sqInt start; + PangoAttribute *pangoAttr; + sqInt end; + sqInt *attrArray; + sqInt c; + + attrArray = interpreterProxy->firstIndexableField(attrArrayOop); + start = ((attrArray[1]) >> 1); + end = ((attrArray[2]) >> 1); + c = ((attrArray[3]) >> 1); + if (c & 1) { + pangoAttr = pango_attr_weight_new(PANGO_WEIGHT_BOLD); + pangoAttr->start_index = start; + pangoAttr->end_index = end; + pango_attr_list_change(pangoAttrList, pangoAttr); + } + if (c & 2) { + pangoAttr = pango_attr_style_new(PANGO_STYLE_OBLIQUE); + pangoAttr->start_index = start; + pangoAttr->end_index = end; + pango_attr_list_change(pangoAttrList, pangoAttr); + } + if (c & 4) { + pangoAttr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE); + pangoAttr->start_index = start; + pangoAttr->end_index = end; + pango_attr_list_change(pangoAttrList, pangoAttr); + } + if (c & 8) { + pangoAttr = pango_attr_stretch_new(PANGO_STRETCH_CONDENSED); + pangoAttr->start_index = start; + pangoAttr->end_index = end; + pango_attr_list_change(pangoAttrList, pangoAttr); + } + if (c & 16) { + pangoAttr = pango_attr_strikethrough_new(1); + pangoAttr->start_index = start; + pangoAttr->end_index = end; + pango_attr_list_change(pangoAttrList, pangoAttr); + } +} + +static sqInt addFontinto(sqInt attrArrayOop, PangoAttrList *pangoAttrList) { + sqInt start; + PangoFontDescription *desc; + sqInt fontDescIndex; + PangoAttribute *pangoAttr; + sqInt end; + sqInt *attrArray; + + attrArray = interpreterProxy->firstIndexableField(attrArrayOop); + start = ((attrArray[1]) >> 1); + end = ((attrArray[2]) >> 1); + fontDescIndex = interpreterProxy->fetchIntegerofObject(5, attrArray[4]); + if (fontDescIndex < 0) { + return null; + } + if (fontDescIndex > 255) { + return null; + } + desc = fontDescriptions[fontDescIndex]; + if (desc == null) { + return null; + } + pangoAttr = pango_attr_font_desc_new(desc); + pangoAttr->start_index = start; + pangoAttr->end_index = end; + pango_attr_list_change(pangoAttrList, pangoAttr); +} + +static sqInt addLanguageinto(sqInt attrArrayOop, PangoAttrList *pangoAttrList) { + sqInt start; + PangoAttribute *pangoAttr; + sqInt end; + sqInt lang; + char *cLang; + sqInt *attrArray; + PangoLanguage *pangoLang; + + attrArray = interpreterProxy->firstIndexableField(attrArrayOop); + start = ((attrArray[1]) >> 1); + end = ((attrArray[2]) >> 1); + lang = ((attrArray[3]) >> 1); + if (lang == 0) { + cLang = "en-US"; + } + if (lang == 5) { + cLang = "ja-JP"; + } + if (lang == 6) { + cLang = "zh-CN"; + } + if (lang == 7) { + cLang = "ko-KR"; + } + if (lang == 9) { + cLang = "zh-TW"; + } + if (lang == 13) { + cLang = "el-EL"; + } + if (lang == 15) { + cLang = "ne-NP"; + } + pangoLang = pango_language_from_string(cLang); + pangoAttr = pango_attr_language_new(pangoLang); + pangoAttr->start_index = start; + pangoAttr->end_index = end; + pango_attr_list_change(pangoAttrList, pangoAttr); +} + +static sqInt addSelectionAtpixelwith(PangoRectangle *rect, unsigned int c, cairo_t*context) { + sqInt a; + sqInt r; + sqInt b; + sqInt g; + + a = ((usqInt) (c & 4278190080U)) >> 24; + if (a == 0) { + return null; + } + r = ((usqInt) (c & 16711680)) >> 16; + g = ((usqInt) (c & 65280)) >> 8; + b = c & 255; + cairo_save(context); + cairo_set_source_rgba(context, r / 255.0, g / 255.0, b / 255.0, a / 255.0); + cairo_new_path(context); + cairo_move_to(context, PANGO_PIXELS(rect->x) + 1, PANGO_PIXELS(rect->y)); + cairo_line_to(context, PANGO_PIXELS(rect->x) + 1, PANGO_PIXELS(rect->y+rect->height)); + cairo_stroke(context); + cairo_restore(context); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } +} + +static sqInt addSelectionFromtopixelinto(sqInt start, sqInt end, unsigned int c, PangoAttrList *pangoAttrList) { + sqInt r; + sqInt b; + PangoAttribute *pangoAttr; + sqInt g; + sqInt alpha; + + alpha = ((usqInt) (c && 4278190080U)) >> 24; + r = ((usqInt) (c & 16711680)) >> 16; + g = ((usqInt) (c & 65280)) >> 8; + b = c & 255; + if ((alpha == 0) && ((r == 0) && ((g == 0) && (b == 0)))) { + return null; + } + if (!(r == 0)) { + r = r * 257; + } + if (!(g == 0)) { + g = g * 257; + } + if (!(b == 0)) { + b = b * 257; + } + pangoAttr = pango_attr_background_new(r, g, b); + pangoAttr->start_index = start; + pangoAttr->end_index = end; + pango_attr_list_change(pangoAttrList, pangoAttr); +} + + +/* Get contexts[canvasOop's handle] */ + +static cairo_t* contextFrom(sqInt canvasOop) { + cairo_t*context; + sqInt contextIndex; + sqInt targetOop; + + if ((interpreterProxy->slotSizeOf(canvasOop)) < CanvasInstSize) { + fail("canvas oop invalid"); + return null; + } + contextIndex = interpreterProxy->fetchIntegerofObject(CanvasHandleIndex, canvasOop); + if (interpreterProxy->failed()) { + contextIndex = interpreterProxy->fetchPointerofObject(CanvasHandleIndex, canvasOop); + if (!(contextIndex == (interpreterProxy->nilObject()))) { + fail("canvas handle not an integer"); + } + return null; + } + if ((contextIndex < 0) || (contextIndex > (lastIndex(contexts)))) { + failwith("canvas handle %i out of bounds", contextIndex); + return null; + } + context = contexts[contextIndex]; + if (context == null) { + failwith("canvas handle %i invalid", contextIndex); + return null; + } + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + targetOop = interpreterProxy->fetchPointerofObject(CanvasTargetIndex, canvasOop); + if (!((surfaceFrom(targetOop)) == (cairo_get_target(context)))) { + failwith("canvas handle %i does not match target", contextIndex); + return null; + } + return context; +} + +static sqInt createContextFor(sqInt canvasOop) { + sqInt i; + cairo_surface_t*targetSurface; + cairo_t*context; + sqInt targetID; + sqInt contextIndex; + sqInt targetOop; + + if ((interpreterProxy->slotSizeOf(canvasOop)) < CanvasInstSize) { + fail("canvas oop invalid"); + return null; + } + targetOop = interpreterProxy->fetchPointerofObject(CanvasTargetIndex, canvasOop); + if ((interpreterProxy->slotSizeOf(targetOop)) <= FormBitsIndex) { + fail("target oop invalid"); + return null; + } + targetID = interpreterProxy->fetchIntegerofObject(FormBitsIndex, targetOop); + if (interpreterProxy->failed()) { + fail("target handle not an integer"); + return null; + } + targetSurface = findSurface(targetID); + if (!((targetSurface != null) && ((cairo_surface_status(targetSurface)) == 0))) { + fail("target surface invalid"); + return null; + } + contextIndex = -1; + i = 0; + while (i <= (lastIndex(contexts))) { + if ((contexts[i]) == null) { + contextIndex = i; + i = lastIndex(contexts); + } + i += 1; + } + if (contextIndex < 0) { + fail("too many canvases"); + return null; + } + context = cairo_create(targetSurface); + contexts[contextIndex] = context; + /* missing DebugCode */; + return contextIndex; +} + + +/* create a surface, register it in SurfacePlugin and answer its surface plugin ID */ + +static sqInt createSurfaceFor(sqInt formOop) { + cairo_format_t format; + sqInt bits; + sqInt width; + sqInt status; + cairo_surface_t*surface; + sqInt height; + sqInt depth; + + if ((interpreterProxy->slotSizeOf(formOop)) < FormInstSize) { + fail("form oop invalid"); + return -1; + } + width = interpreterProxy->fetchIntegerofObject(FormWidthIndex, formOop); + height = interpreterProxy->fetchIntegerofObject(FormHeightIndex, formOop); + depth = interpreterProxy->fetchIntegerofObject(FormDepthIndex, formOop); + if (interpreterProxy->failed()) { + fail("form fields are not integers"); + return -1; + } + switch(depth) { + case 32: format = CAIRO_FORMAT_ARGB32; break; + case 24: format = CAIRO_FORMAT_RGB24; break; + case 16: format = CAIRO_FORMAT_RGB16_565; break; + case 8: format = CAIRO_FORMAT_A8; break; + case 1: format = CAIRO_FORMAT_A1; break; + default: format = -1; + } + if ((width <= 0) || ((height <= 0) || (format < 0))) { + fail("form fields out of range"); + return -1; + } + bits = interpreterProxy->fetchPointerofObject(FormBitsIndex, formOop); + if (!(bits == (interpreterProxy->nilObject()))) { + fail("form handle not nil"); + return -1; + } + surface = cairo_image_surface_create(format, width, height); + status = cairo_surface_status(surface); + if (!(status == 0)) { + failwith("failed to create surface - %s", cairo_status_to_string(status)); + cairo_surface_destroy(surface); + return -1; + } + return registerSurface(surface); +} + +static sqInt destroyContextFor(sqInt canvasOop) { + cairo_t*context; + sqInt contextIndex; + + if ((interpreterProxy->slotSizeOf(canvasOop)) < CanvasInstSize) { + fail("canvas oop invalid"); + return null; + } + contextIndex = interpreterProxy->fetchIntegerofObject(CanvasHandleIndex, canvasOop); + if (interpreterProxy->failed()) { + fail("canvas handle not an integer"); + return null; + } + if ((contextIndex < 0) || (contextIndex > (lastIndex(contexts)))) { + failwith("canvas handle %i out of bounds", contextIndex); + return null; + } + context = contexts[contextIndex]; + if (context == null) { + failwith("canvas handle %i invalid", contextIndex); + return null; + } + /* missing DebugCode */; + cairo_destroy(context); + contexts[contextIndex] = null; + return null; +} + + +/* fetch surface from surfaceID, destroy it and unregister from SurfacePlugin */ + +static sqInt destroySurface(sqInt surfaceID) { + cairo_surface_t*surface; + + surface = findSurface(surfaceID); + if (surface == null) { + failwith("could not find surface %i", surfaceID); + return null; + } + cairo_surface_destroy(surface); + unregisterSurface(surfaceID); + return null; +} + + +/* fill or stroke depending on canvasOop's flags */ + +static void fillOrStrokefrom(cairo_t*context, sqInt canvasOop) { + sqInt stroke; + sqInt canvasFlags; + sqInt fill; + sqInt rgb; + + canvasFlags = interpreterProxy->fetchIntegerofObject(CanvasFlagsIndex, canvasOop); + if (interpreterProxy->failed()) { + fail("canvas flags not an integer"); + } else { + fill = canvasFlags & CanvasFlagFill; + stroke = canvasFlags & CanvasFlagStroke; + if (fill != 0) { + if (stroke != 0) { + cairo_fill_preserve(context); + } else { + cairo_fill(context); + } + } + if (stroke != 0) { + rgb = interpreterProxy->fetchIntegerofObject(CanvasStrokeColorIndex, canvasOop); + cairo_save(context); + setSourcergbalpha(context, rgb, stroke); + cairo_stroke(context); + cairo_restore(context); + } + } +} + + +/* Answer surface handle for surfaceID */ + +static cairo_surface_t* findSurface(sqInt surfaceID) { + sqInt surfaceHandle; + + if (findSurfaceFn == null) { + if (!(loadSurfacePlugin())) { + return null; + } + } + if (!((*findSurfaceFn)(surfaceID, &surfaceDispatch, &surfaceHandle))) { + return null; + } + return ((cairo_surface_t*) surfaceHandle); +} + + +/* Note: This is coded so that plugins can be run from Squeak. */ + +static VirtualMachine * getInterpreter(void) { + return interpreterProxy; +} + + +/* Note: This is hardcoded so it can be run from Squeak. + The module name is used for validating a module *after* + it is loaded to check if it does really contain the module + we're thinking it contains. This is important! */ + +EXPORT(const char*) getModuleName(void) { + return moduleName; +} + +static sqInt getSurfaceFormatgetWgetHgetDgetMsb(cairo_surface_t *surfaceHandle, int*wReturn, int*hReturn, int*dReturn, int*mReturn) { + sqInt msb; + sqInt width; + sqInt depth; + sqInt height; + + /* missing DebugCode */; + width = cairo_image_surface_get_width(surfaceHandle); + height = cairo_image_surface_get_height(surfaceHandle); + depth = formatToDepth[cairo_image_surface_get_format(surfaceHandle)]; + msb = 1; + *wReturn = width; + *hReturn = height; + *dReturn = depth; + *mReturn = msb; + return 1; +} + +static sqInt halt(void) { + ; +} + +EXPORT(sqInt) initialiseModule(void) { + sqInt i; + + for (i = 0; i <= (lastIndex(contexts)); i += 1) { + contexts[i] = null; + } + for (i = 0; i <= (lastIndex(fontDescriptions)); i += 1) { + fontDescriptions[i] = null; + } + defaultFontDescription = pango_font_description_from_string("Times New Roman 10"); + registerSurfaceFn = null; + unregisterSurfaceFn = null; + findSurfaceFn = null; + return 1; +} + +static sqInt leadingCharOf(unsigned int value) { + return ((usqInt) (value & 1069547520) >> 22); +} + + +/* Load the surface support plugin */ + +static sqInt loadSurfacePlugin(void) { + sqInt found; + + registerSurfaceFn = ((fn_ioRegisterSurface) (interpreterProxy->ioLoadFunctionFrom("ioRegisterSurface", "SurfacePlugin"))); + unregisterSurfaceFn = ((fn_ioUnregisterSurface) (interpreterProxy->ioLoadFunctionFrom("ioUnregisterSurface", "SurfacePlugin"))); + findSurfaceFn = ((fn_ioFindSurface) (interpreterProxy->ioLoadFunctionFrom("ioFindSurface", "SurfacePlugin"))); + found = (registerSurfaceFn != null) && ((unregisterSurfaceFn != null) && (findSurfaceFn != null)); + if (!(found)) { + fail("could not load SurfacePlugin"); + } + maxSurfaceID = -1; + return found; +} + +static unsigned char* lockSurfacegetPitchxywh(cairo_surface_t*surfaceHandle, int*pitchReturn, sqInt x, sqInt y, sqInt w, sqInt h) { + sqInt pitch; + unsigned char*data; + + /* missing DebugCode */; + cairo_surface_flush(surfaceHandle); + data = cairo_image_surface_get_data(surfaceHandle); + pitch = cairo_image_surface_get_stride(surfaceHandle); + *pitchReturn = pitch; + return data; +} + + +/* The module with the given name was just unloaded. + Make sure we have no dangling references. */ + +EXPORT(sqInt) moduleUnloaded(char *aModuleName) { + if ((strcmp(aModuleName, "SurfacePlugin")) == 0) { + registerSurfaceFn = null; + unregisterSurfaceFn = null; + findSurfaceFn = null; + } + return 1; +} + +static sqInt msg(char *s) { + fprintf(stderr, "\n%s: %s", moduleName, s); +} + +static void polyPathfrom(cairo_t*context, sqInt pointsOop) { + float*points; + sqInt i; + sqInt pointsCount; + + points = interpreterProxy->arrayValueOf(pointsOop); + pointsCount = interpreterProxy->slotSizeOf(pointsOop); + if (!(interpreterProxy->failed())) { + if (pointsCount >= 2) { + cairo_move_to(context, points[0], points[1]); + for (i = 2; i <= (pointsCount - 1); i += 2) { + cairo_line_to(context, points[i], points[i + 1]); + } + } + } +} + +EXPORT(sqInt) primitivePangoBlockAtIndex(void) { + sqInt index; + cairo_t*context; + sqInt origin; + unsigned char*aString; + sqInt trailing; + sqInt aStringOop; + sqInt stringLength; + PangoAttrList*attrList; + sqInt atEnd; + PangoLayout*layout; + sqInt canvasOop; + sqInt corner; + sqInt charData; + PangoRectangle pos; + sqInt inStringOop; + sqInt utf8Index; + sqInt x; + sqInt y; + sqInt sqAttrArray; + sqInt w; + sqInt h; + sqInt withWrap; + sqInt cData; + sqInt _return_value; + + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(8), "Object")); + inStringOop = interpreterProxy->stackValue(8); + utf8Index = interpreterProxy->stackIntegerValue(7); + x = interpreterProxy->stackIntegerValue(6); + y = interpreterProxy->stackIntegerValue(5); + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(4), "Object")); + sqAttrArray = interpreterProxy->stackValue(4); + w = interpreterProxy->stackIntegerValue(3); + h = interpreterProxy->stackIntegerValue(2); + withWrap = interpreterProxy->booleanValueOf(interpreterProxy->stackValue(1)); + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "Object")); + cData = interpreterProxy->stackValue(0); + ; + canvasOop = interpreterProxy->stackValue(9); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + aStringOop = inStringOop; + aString = interpreterProxy->firstIndexableField(aStringOop); + layout = pango_cairo_create_layout(context); + attrList = pango_attr_list_new(); + translateSqAttrsToPangoAttrsinto(sqAttrArray, attrList); + pango_layout_set_text(layout, aString, strlen(aString)); + pango_layout_set_attributes(layout, attrList); + pango_layout_set_width(layout, w * (PANGO_SCALE)); + if (withWrap) { + pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR); + } + cairo_translate(context, x, y); + pango_cairo_update_layout(context, layout); + stringLength = strlen(aString); + if (utf8Index == (stringLength + 1)) { + atEnd = 1; + pango_layout_index_to_pos(layout, ((((((utf8Index - 1) < 0) ? 0 : (utf8Index - 1))) < stringLength) ? ((((utf8Index - 1) < 0) ? 0 : (utf8Index - 1))) : stringLength), &pos); + pos.x = pos.x + pos.width; + } else { + atEnd = 0; + pango_layout_index_to_pos(layout, (((((utf8Index < 0) ? 0 : utf8Index)) < stringLength) ? (((utf8Index < 0) ? 0 : utf8Index)) : stringLength), &pos); + } + pango_attr_list_unref(attrList); + g_object_unref(layout); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + interpreterProxy->pushRemappableOop(aStringOop); + interpreterProxy->pushRemappableOop(cData); + origin = interpreterProxy->makePointwithxValueyValue((PANGO_PIXELS(pos.x)) + x, (PANGO_PIXELS(pos.y)) + y); + interpreterProxy->pushRemappableOop(origin); + corner = interpreterProxy->makePointwithxValueyValue((PANGO_PIXELS(pos.x+pos.width)) + x, (PANGO_PIXELS(pos.y+pos.height)) + y); + origin = interpreterProxy->popRemappableOop(); + charData = interpreterProxy->popRemappableOop(); + aStringOop = interpreterProxy->popRemappableOop(); + aString = interpreterProxy->firstIndexableField(aStringOop); + interpreterProxy->storePointerofObjectwithValue(0, charData, origin); + interpreterProxy->storePointerofObjectwithValue(1, charData, corner); + index = sqCharCountInfromto(aString, 0, utf8Index); + if (!(atEnd)) { + index += 1; + } + interpreterProxy->storePointerofObjectwithValue(2, charData, ((index << 1) | 1)); + _return_value = interpreterProxy->integerObjectOf(index); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(10, _return_value); + return null; +} + +EXPORT(sqInt) primitiveClear(void) { + sqInt op; + sqInt canvasFlags; + sqInt fill; + cairo_t*context; + sqInt canvasOop; + + canvasOop = interpreterProxy->stackValue(0); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + canvasFlags = interpreterProxy->fetchIntegerofObject(CanvasFlagsIndex, canvasOop); + if (interpreterProxy->failed()) { + fail("canvas flags not an integer"); + return null; + } + fill = canvasFlags & CanvasFlagFill; + if (!(fill)) { + cairo_set_source_rgba(context, 0.0, 0.0, 0.0, 0.0); + } + op = cairo_get_operator(context); + cairo_set_operator(context, CairoOperatorSource); + cairo_paint(context); + cairo_set_operator(context, op); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + return null; +} + +EXPORT(sqInt) primitiveClipRectangleLeftRightTopBottom(void) { + cairo_t*context; + sqInt canvasOop; + double left; + double right; + double top; + double bottom; + + left = interpreterProxy->stackFloatValue(3); + right = interpreterProxy->stackFloatValue(2); + top = interpreterProxy->stackFloatValue(1); + bottom = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(4); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_new_path(context); + cairo_rectangle(context, left, top, right - left, bottom - top); + cairo_clip(context); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(4); + return null; +} + +EXPORT(sqInt) primitiveClose(void) { + sqInt canvasOop; + + canvasOop = interpreterProxy->stackValue(0); + if (interpreterProxy->failed()) { + return null; + } + destroyContextFor(canvasOop); + if (!(interpreterProxy->failed())) { + interpreterProxy->storePointerofObjectwithValue(CanvasHandleIndex, canvasOop, interpreterProxy->nilObject()); + } + if (interpreterProxy->failed()) { + return null; + } + return null; +} + +EXPORT(sqInt) primitivePangoComposeString(void) { + cairo_t*context; + sqInt linesSize; + sqInt newW; + sqInt sqStart; + sqInt lineCount; + PangoRectangle ink; + sqInt start; + sqInt lineIndex; + PangoAttrList*attrList; + sqInt sqEnd; + sqInt baseline; + PangoLayoutLine*line; + PangoRectangle logical; + sqInt totalY; + sqInt prevBaseline; + PangoLayout*layout; + sqInt lastLine; + sqInt canvasOop; + sqInt addition; + PangoLayoutIter*lineIter; + sqInt next; + char *aString; + sqInt x; + sqInt y; + sqInt sqAttrArray; + sqInt w; + sqInt h; + sqInt withWrap; + sqInt lines; + sqInt _return_value; + + interpreterProxy->success(interpreterProxy->isBytes(interpreterProxy->stackValue(7))); + aString = ((char *) (interpreterProxy->firstIndexableField(interpreterProxy->stackValue(7)))); + x = interpreterProxy->stackIntegerValue(6); + y = interpreterProxy->stackIntegerValue(5); + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(4), "Object")); + sqAttrArray = interpreterProxy->stackValue(4); + w = interpreterProxy->stackIntegerValue(3); + h = interpreterProxy->stackIntegerValue(2); + withWrap = interpreterProxy->booleanValueOf(interpreterProxy->stackValue(1)); + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "Object")); + lines = interpreterProxy->stackValue(0); + ; + canvasOop = interpreterProxy->stackValue(8); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + layout = pango_cairo_create_layout(context); + attrList = pango_attr_list_new(); + translateSqAttrsToPangoAttrsinto(sqAttrArray, attrList); + pango_layout_set_text(layout, aString, strlen(aString)); + pango_layout_set_attributes(layout, attrList); + pango_layout_set_width(layout, w * (PANGO_SCALE)); + if (withWrap) { + pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR); + } + cairo_translate(context, x, y); + pango_cairo_update_layout(context, layout); + lineCount = pango_layout_get_line_count(layout); + lineIter = pango_layout_get_iter(layout); + baseline = pango_layout_iter_get_baseline(lineIter); + prevBaseline = 0; + cairo_translate(context, 0, PANGO_PIXELS(baseline)); + sqEnd = 0; + totalY = 0; + linesSize = interpreterProxy->stSizeOf(lines); + lastLine = (((lineCount < linesSize) ? lineCount : linesSize)) - 1; + for (lineIndex = 0; lineIndex <= lastLine; lineIndex += 1) { + line = pango_layout_iter_get_line_readonly(lineIter); + pango_layout_line_get_extents(line, &ink, &logical); + sqStart = sqEnd + 1; + start = line->start_index; + + /* self log: 'sqStart, sqEnd: %d %d' with: sqStart with: sqEnd. */ + + sqEnd = (sqStart + (sqCharCountInfromto(aString, start, start + (line->length)))) - 1; + if (((start + (line->length)) < (interpreterProxy->stSizeOf(((int) aString)))) && ((aString[start + (line->length)]) == 13)) { + sqEnd += 1; + } + interpreterProxy->storeIntegerofObjectwithValue(TextLineStartIndex, interpreterProxy->fetchPointerofObject(lineIndex, lines), sqStart); + interpreterProxy->storeIntegerofObjectwithValue(TextLineEndIndex, interpreterProxy->fetchPointerofObject(lineIndex, lines), sqEnd); + interpreterProxy->storeIntegerofObjectwithValue(TextLineLeftIndex, interpreterProxy->fetchPointerofObject(lineIndex, lines), (PANGO_PIXELS(logical.x)) + x); + interpreterProxy->storeIntegerofObjectwithValue(TextLineRightIndex, interpreterProxy->fetchPointerofObject(lineIndex, lines), (PANGO_PIXELS(logical.x+logical.width)) + x); + interpreterProxy->storeIntegerofObjectwithValue(TextLineTopIndex, interpreterProxy->fetchPointerofObject(lineIndex, lines), totalY + y); + interpreterProxy->storeIntegerofObjectwithValue(TextLineInternalSpaceIndex, interpreterProxy->fetchPointerofObject(lineIndex, lines), ((0 << 1) | 1)); + interpreterProxy->storeIntegerofObjectwithValue(TextLinePaddingWidthIndex, interpreterProxy->fetchPointerofObject(lineIndex, lines), ((0 << 1) | 1)); + next = pango_layout_iter_next_line(lineIter); + if (next) { + addition = (logical.height) + (pango_layout_get_spacing(layout)); + } else { + addition = logical.height; + } + totalY += PANGO_PIXELS(addition); + interpreterProxy->storeIntegerofObjectwithValue(TextLineBottomIndex, interpreterProxy->fetchPointerofObject(lineIndex, lines), totalY + y); + } + pango_layout_get_extents(layout, &ink, &logical); + newW = PANGO_PIXELS(logical.width); + pango_layout_iter_free(lineIter); + pango_attr_list_unref(attrList); + g_object_unref(layout); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + _return_value = interpreterProxy->integerObjectOf(newW); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(9, _return_value); + return null; +} + +EXPORT(sqInt) primitivePangoComposeString2(void) { + cairo_t*context; + sqInt newW; + sqInt sqStart; + sqInt lineCount; + PangoRectangle ink; + unsigned char*aString; + unsigned char*inString; + sqInt start; + sqInt lineIndex; + PangoAttrList*attrList; + sqInt sqEnd; + sqInt baseline; + PangoLayoutLine*line; + PangoRectangle logical; + sqInt totalY; + sqInt prevBaseline; + sqInt arrayOop; + sqInt retArrayOop; + sqInt textLine; + sqInt i; + PangoLayout*layout; + sqInt lastLine; + sqInt canvasOop; + sqInt addition; + sqInt textLineClass; + sqInt inStringSize; + PangoLayoutIter*lineIter; + sqInt next; + sqInt inStringOop; + sqInt x; + sqInt y; + sqInt sqAttrArray; + sqInt w; + sqInt h; + sqInt withWrap; + sqInt inTextLineClass; + + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(7), "Object")); + inStringOop = interpreterProxy->stackValue(7); + x = interpreterProxy->stackIntegerValue(6); + y = interpreterProxy->stackIntegerValue(5); + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(4), "Object")); + sqAttrArray = interpreterProxy->stackValue(4); + w = interpreterProxy->stackIntegerValue(3); + h = interpreterProxy->stackIntegerValue(2); + withWrap = interpreterProxy->booleanValueOf(interpreterProxy->stackValue(1)); + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "Object")); + inTextLineClass = interpreterProxy->stackValue(0); + ; + canvasOop = interpreterProxy->stackValue(8); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + inStringSize = interpreterProxy->stSizeOf(inStringOop); + if (inStringSize == 0) { + primitiveFail(); + return null; + } + aString = alloca(inStringSize); + inString = interpreterProxy->firstIndexableField(inStringOop); + strncpy(aString, inString, inStringSize); + textLineClass = inTextLineClass; + layout = pango_cairo_create_layout(context); + attrList = pango_attr_list_new(); + translateSqAttrsToPangoAttrsinto(sqAttrArray, attrList); + pango_layout_set_text(layout, aString, strlen(aString)); + pango_layout_set_attributes(layout, attrList); + pango_layout_set_width(layout, w * (PANGO_SCALE)); + if (withWrap) { + pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR); + } + cairo_translate(context, x, y); + pango_cairo_update_layout(context, layout); + lineCount = pango_layout_get_line_count(layout); + lineIter = pango_layout_get_iter(layout); + baseline = pango_layout_iter_get_baseline(lineIter); + prevBaseline = 0; + cairo_translate(context, 0, PANGO_PIXELS(baseline)); + sqEnd = 0; + totalY = 0; + interpreterProxy->pushRemappableOop(textLineClass); + arrayOop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classArray(), lineCount); + textLineClass = interpreterProxy->popRemappableOop(); + for (i = 0; i <= (lineCount - 1); i += 1) { + interpreterProxy->pushRemappableOop(textLineClass); + interpreterProxy->pushRemappableOop(arrayOop); + textLine = interpreterProxy->instantiateClassindexableSize(textLineClass, 0); + arrayOop = interpreterProxy->popRemappableOop(); + textLineClass = interpreterProxy->popRemappableOop(); + interpreterProxy->storePointerofObjectwithValue(i, arrayOop, textLine); + } + lastLine = lineCount - 1; + for (lineIndex = 0; lineIndex <= lastLine; lineIndex += 1) { + line = pango_layout_iter_get_line_readonly(lineIter); + pango_layout_line_get_extents(line, &ink, &logical); + sqStart = sqEnd + 1; + start = line->start_index; + + /* self log: 'sqStart, sqEnd: %d %d' with: sqStart with: sqEnd. */ + + sqEnd = (sqStart + (sqCharCountInfromto(aString, start, start + (line->length)))) - 1; + if (((start + (line->length)) < (interpreterProxy->stSizeOf(((int) aString)))) && ((aString[start + (line->length)]) == 13)) { + sqEnd += 1; + } + interpreterProxy->storeIntegerofObjectwithValue(TextLineStartIndex, interpreterProxy->fetchPointerofObject(lineIndex, arrayOop), sqStart); + interpreterProxy->storeIntegerofObjectwithValue(TextLineEndIndex, interpreterProxy->fetchPointerofObject(lineIndex, arrayOop), sqEnd); + interpreterProxy->storeIntegerofObjectwithValue(TextLineLeftIndex, interpreterProxy->fetchPointerofObject(lineIndex, arrayOop), (PANGO_PIXELS(logical.x)) + x); + interpreterProxy->storeIntegerofObjectwithValue(TextLineRightIndex, interpreterProxy->fetchPointerofObject(lineIndex, arrayOop), (PANGO_PIXELS(logical.x+logical.width)) + x); + interpreterProxy->storeIntegerofObjectwithValue(TextLineTopIndex, interpreterProxy->fetchPointerofObject(lineIndex, arrayOop), totalY + y); + interpreterProxy->storeIntegerofObjectwithValue(TextLineInternalSpaceIndex, interpreterProxy->fetchPointerofObject(lineIndex, arrayOop), ((0 << 1) | 1)); + interpreterProxy->storeIntegerofObjectwithValue(TextLinePaddingWidthIndex, interpreterProxy->fetchPointerofObject(lineIndex, arrayOop), ((0 << 1) | 1)); + next = pango_layout_iter_next_line(lineIter); + if (next) { + addition = (logical.height) + (pango_layout_get_spacing(layout)); + } else { + addition = logical.height; + } + totalY += PANGO_PIXELS(addition); + interpreterProxy->storeIntegerofObjectwithValue(TextLineBottomIndex, interpreterProxy->fetchPointerofObject(lineIndex, arrayOop), totalY + y); + } + pango_layout_get_extents(layout, &ink, &logical); + newW = PANGO_PIXELS(logical.width); + pango_layout_iter_free(lineIter); + pango_attr_list_unref(attrList); + g_object_unref(layout); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + interpreterProxy->pushRemappableOop(arrayOop); + retArrayOop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classArray(), 2); + arrayOop = interpreterProxy->popRemappableOop(); + interpreterProxy->storeIntegerofObjectwithValue(0, retArrayOop, newW); + interpreterProxy->storePointerofObjectwithValue(1, retArrayOop, arrayOop); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(9, retArrayOop); + return null; +} + +EXPORT(sqInt) primitiveCreateFormHandle(void) { + sqInt formOop; + sqInt surfaceID; + sqInt _return_value; + + formOop = interpreterProxy->stackValue(0); + if (interpreterProxy->failed()) { + return null; + } + surfaceID = createSurfaceFor(formOop); + if (surfaceID < 0) { + interpreterProxy->primitiveFail(); + } + if (!(interpreterProxy->failed())) { + _return_value = interpreterProxy->integerObjectOf(surfaceID); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(1, _return_value); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + return null; +} + +EXPORT(sqInt) primitiveDestroyFormHandle(void) { + sqInt surfaceID; + + surfaceID = interpreterProxy->stackIntegerValue(0); + if (interpreterProxy->failed()) { + return null; + } + if (!(interpreterProxy->failed())) { + destroySurface(surfaceID); + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(1); + return null; +} + +EXPORT(sqInt) primitiveDrawArcRadiusXYFromTo(void) { + cairo_t*context; + sqInt canvasOop; + double radius; + double x; + double y; + double angle1; + double angle2; + + radius = interpreterProxy->stackFloatValue(4); + x = interpreterProxy->stackFloatValue(3); + y = interpreterProxy->stackFloatValue(2); + angle1 = interpreterProxy->stackFloatValue(1); + angle2 = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(5); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_new_path(context); + if (radius > 0.0) { + cairo_arc(context, x, y, radius, angle1, angle2); + } else { + cairo_arc_negative(context, x, y, -1.0 * radius, angle1, angle2); + } + fillOrStrokefrom(context, canvasOop); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(5); + return null; +} + +EXPORT(sqInt) primitiveDrawCurveFromXYviaXYandXYtoXY(void) { + cairo_t*context; + sqInt canvasOop; + double x0; + double y0; + double x1; + double y1; + double x2; + double y2; + double x3; + double y3; + + x0 = interpreterProxy->stackFloatValue(7); + y0 = interpreterProxy->stackFloatValue(6); + x1 = interpreterProxy->stackFloatValue(5); + y1 = interpreterProxy->stackFloatValue(4); + x2 = interpreterProxy->stackFloatValue(3); + y2 = interpreterProxy->stackFloatValue(2); + x3 = interpreterProxy->stackFloatValue(1); + y3 = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(8); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_new_path(context); + cairo_move_to(context, x0, y0); + cairo_curve_to(context, x1, y1, x2, y2, x3, y3); + fillOrStrokefrom(context, canvasOop); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(8); + return null; +} + +EXPORT(sqInt) primitiveDrawCurveFromXYviaXYtoXY(void) { + cairo_t*context; + sqInt canvasOop; + double x0; + double y0; + double x1; + double y1; + double x2; + double y2; + + x0 = interpreterProxy->stackFloatValue(5); + y0 = interpreterProxy->stackFloatValue(4); + x1 = interpreterProxy->stackFloatValue(3); + y1 = interpreterProxy->stackFloatValue(2); + x2 = interpreterProxy->stackFloatValue(1); + y2 = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(6); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_new_path(context); + cairo_move_to(context, x0, y0); + cairo_curve_to(context, ((2.0 * x1) + x0) / 3.0, ((2.0 * y1) + y0) / 3.0, ((2.0 * x1) + x2) / 3.0, ((2.0 * y1) + y2) / 3.0, x2, y2); + fillOrStrokefrom(context, canvasOop); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(6); + return null; +} + +EXPORT(sqInt) primitiveDrawGeneralBezierShape(void) { + cairo_t*context; + sqInt shapeCount; + sqInt segmentCount; + short*seg; + sqInt j; + sqInt yVia; + sqInt i; + sqInt xFrom; + sqInt contourOop; + sqInt canvasOop; + sqInt xTo; + sqInt yTo; + sqInt xVia; + sqInt yFrom; + sqInt shapeOop; + + shapeOop = interpreterProxy->stackValue(0); + canvasOop = interpreterProxy->stackValue(1); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + shapeCount = interpreterProxy->slotSizeOf(shapeOop); + cairo_new_path(context); + for (i = 0; i <= (shapeCount - 1); i += 1) { + contourOop = interpreterProxy->fetchPointerofObject(i, shapeOop); + if (!(interpreterProxy->isMemberOf(contourOop, "ShortPointArray"))) { + failwith("bezier contour %i is no ShortPointArray", i + 1); + return null; + } + segmentCount = (interpreterProxy->slotSizeOf(contourOop)) / 3; + seg = interpreterProxy->arrayValueOf(contourOop); + for (j = 0; j <= (segmentCount - 1); j += 1) { + xFrom = seg[0]; + yFrom = seg[1]; + xVia = seg[2]; + yVia = seg[3]; + xTo = seg[4]; + yTo = seg[5]; + if (j == 0) { + cairo_move_to(context, xFrom, yFrom); + } + if ((xFrom == xVia) && (yFrom == yVia)) { + cairo_line_to(context, xTo, yTo); + } else { + cairo_curve_to(context, (xFrom + (2.0 * xVia)) / 3.0, (yFrom + (2.0 * yVia)) / 3.0, ((2.0 * xVia) + xTo) / 3.0, ((2.0 * yVia) + yTo) / 3.0, xTo, yTo); + } + seg += 6; + } + cairo_close_path(context); + } + fillOrStrokefrom(context, canvasOop); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(1); + return null; +} + +EXPORT(sqInt) primitiveDrawImageSrcLRTBDestLRTB(void) { + cairo_surface_t*srcSurface; + cairo_t*context; + sqInt canvasOop; + sqInt formOop; + double dstL; + double dstR; + double dstT; + double dstB; + double srcL; + double srcR; + double srcT; + double srcB; + + formOop = interpreterProxy->stackValue(8); + dstL = interpreterProxy->stackFloatValue(7); + dstR = interpreterProxy->stackFloatValue(6); + dstT = interpreterProxy->stackFloatValue(5); + dstB = interpreterProxy->stackFloatValue(4); + srcL = interpreterProxy->stackFloatValue(3); + srcR = interpreterProxy->stackFloatValue(2); + srcT = interpreterProxy->stackFloatValue(1); + srcB = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(9); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + srcSurface = surfaceFrom(formOop); + if (!((srcSurface != null) && ((cairo_surface_status(srcSurface)) == 0))) { + fail("source surface invalid"); + return null; + } + if ((srcR != srcL) && (srcT != srcB)) { + cairo_save(context); + cairo_translate(context, dstL, dstT); + cairo_scale(context, (dstR - dstL) / (srcR - srcL), (dstB - dstT) / (srcB - srcT)); + cairo_new_path(context); + cairo_rectangle(context, 0.0, 0.0, srcR - srcL, srcB - srcT); + cairo_set_source_surface(context, srcSurface, 0.0 - srcL, 0.0 - srcT); + cairo_fill(context); + cairo_restore(context); + } + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(9); + return null; +} + +EXPORT(sqInt) primitiveDrawLineFromXYtoXY(void) { + cairo_t*context; + sqInt canvasOop; + double fromX; + double fromY; + double toX; + double toY; + + fromX = interpreterProxy->stackFloatValue(3); + fromY = interpreterProxy->stackFloatValue(2); + toX = interpreterProxy->stackFloatValue(1); + toY = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(4); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_new_path(context); + cairo_move_to(context, fromX, fromY); + cairo_line_to(context, toX, toY); + strokefrom(context, canvasOop); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(4); + return null; +} + +EXPORT(sqInt) primitiveDrawOvalLeftRightTopBottom(void) { + cairo_t*context; + sqInt canvasOop; + double left; + double right; + double top; + double bottom; + + left = interpreterProxy->stackFloatValue(3); + right = interpreterProxy->stackFloatValue(2); + top = interpreterProxy->stackFloatValue(1); + bottom = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(4); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + if ((right != left) && (top != bottom)) { + cairo_save(context); + cairo_new_path(context); + cairo_translate(context, (left + right) / 2.0, (top + bottom) / 2.0); + cairo_scale(context, (right - left) / 2.0, (bottom - top) / 2.0); + cairo_arc(context, 0.0, 0.0, 1.0, 0.0, degrees(360.0)); + cairo_restore(context); + fillOrStrokefrom(context, canvasOop); + } + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(4); + return null; +} + +EXPORT(sqInt) primitiveDrawPolygon(void) { + cairo_t*context; + sqInt canvasOop; + sqInt pointsOop; + + pointsOop = interpreterProxy->stackValue(0); + canvasOop = interpreterProxy->stackValue(1); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_new_path(context); + polyPathfrom(context, pointsOop); + cairo_close_path(context); + fillOrStrokefrom(context, canvasOop); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(1); + return null; +} + +EXPORT(sqInt) primitiveDrawPolyline(void) { + cairo_t*context; + sqInt canvasOop; + sqInt pointsOop; + + pointsOop = interpreterProxy->stackValue(0); + canvasOop = interpreterProxy->stackValue(1); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_new_path(context); + polyPathfrom(context, pointsOop); + fillOrStrokefrom(context, canvasOop); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(1); + return null; +} + +EXPORT(sqInt) primitiveDrawRectangleLeftRightTopBottom(void) { + cairo_t*context; + sqInt canvasOop; + double left; + double right; + double top; + double bottom; + + left = interpreterProxy->stackFloatValue(3); + right = interpreterProxy->stackFloatValue(2); + top = interpreterProxy->stackFloatValue(1); + bottom = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(4); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_new_path(context); + cairo_rectangle(context, left, top, right - left, bottom - top); + fillOrStrokefrom(context, canvasOop); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(4); + return null; +} + + +/* x1 x2 x3 x4 + y1 + / - \ + + y2 / . . \ + | | + y3 \ . . / + y4 + \ - / + */ + +EXPORT(sqInt) primitiveDrawRoundRectLeftRightTopBottomRadiusCorner(void) { + cairo_t*context; + double y3; + double y2; + double x3; + double x2; + sqInt canvasOop; + double ry; + double rx; + double r; + double x1; + double x4; + double y1; + double y4; + double radius; + sqInt cornerFlags; + + x1 = interpreterProxy->stackFloatValue(5); + x4 = interpreterProxy->stackFloatValue(4); + y1 = interpreterProxy->stackFloatValue(3); + y4 = interpreterProxy->stackFloatValue(2); + radius = interpreterProxy->stackFloatValue(1); + cornerFlags = interpreterProxy->stackIntegerValue(0); + canvasOop = interpreterProxy->stackValue(6); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + rx = (x4 - x1) / 2.0; + ry = (y4 - y1) / 2.0; + r = (((((radius < rx) ? radius : rx)) < ry) ? (((radius < rx) ? radius : rx)) : ry); + x2 = x1 + r; + x3 = x4 - r; + y2 = y1 + r; + y3 = y4 - r; + cairo_new_path(context); + if (cornerFlags & 1) { + cairo_arc(context, x2, y2, r, degrees(180), degrees(270)); + } else { + cairo_move_to(context, x1, y1); + } + if (cornerFlags & 8) { + cairo_arc(context, x3, y2, r, degrees(270), degrees(360)); + } else { + cairo_line_to(context, x4, y1); + } + if (cornerFlags & 4) { + cairo_arc(context, x3, y3, r, degrees(0), degrees(90)); + } else { + cairo_line_to(context, x4, y4); + } + if (cornerFlags & 2) { + cairo_arc(context, x2, y3, r, degrees(90), degrees(180)); + } else { + cairo_line_to(context, x1, y4); + } + cairo_close_path(context); + fillOrStrokefrom(context, canvasOop); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(6); + return null; +} + + +/* draw a string including its outline if selected */ + +EXPORT(sqInt) primitiveDrawZeroTerminatedUtf8StringXY(void) { + cairo_t*context; + sqInt canvasOop; + char *aString; + double x; + double y; + + interpreterProxy->success(interpreterProxy->isBytes(interpreterProxy->stackValue(2))); + aString = ((char *) (interpreterProxy->firstIndexableField(interpreterProxy->stackValue(2)))); + x = interpreterProxy->stackFloatValue(1); + y = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(3); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_move_to(context, x, y); + cairo_text_path(context, aString); + fillOrStrokefrom(context, canvasOop); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(3); + return null; +} + +EXPORT(sqInt) primitiveFillBitmapOriginXYdirectionXYnormalXYRepeatImage(void) { + cairo_pattern_t*pattern; + cairo_t*context; + sqInt canvasOop; + cairo_matrix_t*m; + cairo_matrix_t mdata; + cairo_surface_t*surface; + double ox; + double oy; + double dx; + double dy; + double nx; + double ny; + sqInt aBoolean; + sqInt formOop; + + ox = interpreterProxy->stackFloatValue(7); + oy = interpreterProxy->stackFloatValue(6); + dx = interpreterProxy->stackFloatValue(5); + dy = interpreterProxy->stackFloatValue(4); + nx = interpreterProxy->stackFloatValue(3); + ny = interpreterProxy->stackFloatValue(2); + aBoolean = interpreterProxy->booleanValueOf(interpreterProxy->stackValue(1)); + formOop = interpreterProxy->stackValue(0); + m = &mdata; + canvasOop = interpreterProxy->stackValue(8); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + surface = surfaceFrom(formOop); + if (!((surface != null) && ((cairo_surface_status(surface)) == 0))) { + fail("surface invalid"); + return null; + } + pattern = cairo_pattern_create_for_surface(surface); + cairo_matrix_init(m, dx, dy, nx, ny, ox, oy); + cairo_matrix_invert(m); + cairo_pattern_set_matrix(pattern, m); + if (aBoolean) { + cairo_pattern_set_extend(pattern, CairoExtendRepeat); + } + if (cairo_pattern_status(pattern)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_pattern_status(pattern))); + return null; + } + cairo_set_source(context, pattern); + cairo_pattern_destroy(pattern); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(8); + return null; +} + +EXPORT(sqInt) primitiveFillColorAlpha(void) { + cairo_t*context; + sqInt canvasOop; + sqInt rgb; + sqInt alpha; + + rgb = interpreterProxy->stackIntegerValue(1); + alpha = interpreterProxy->stackIntegerValue(0); + canvasOop = interpreterProxy->stackValue(2); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + setSourcergbalpha(context, rgb, alpha); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(2); + return null; +} + +EXPORT(sqInt) primitiveFillLinearOriginXYdirectionXYcolorStops(void) { + cairo_pattern_t*pattern; + int*colorStops; + sqInt i; + sqInt colorStopsCount; + cairo_t*context; + sqInt canvasOop; + double ox; + double oy; + double dx; + double dy; + sqInt colorStopsOop; + + ox = interpreterProxy->stackFloatValue(4); + oy = interpreterProxy->stackFloatValue(3); + dx = interpreterProxy->stackFloatValue(2); + dy = interpreterProxy->stackFloatValue(1); + colorStopsOop = interpreterProxy->stackValue(0); + canvasOop = interpreterProxy->stackValue(5); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + colorStops = interpreterProxy->arrayValueOf(colorStopsOop); + colorStopsCount = interpreterProxy->slotSizeOf(colorStopsOop); + if (interpreterProxy->failed()) { + fail("bad colorStops array"); + return null; + } + pattern = cairo_pattern_create_linear(ox, oy, ox + dx, oy + dy); + if (cairo_pattern_status(pattern)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_pattern_status(pattern))); + return null; + } + for (i = 0; i <= (colorStopsCount - 1); i += 3) { + addColorStopTooffsetrgbalpha(pattern, colorStops[i], colorStops[i + 1], colorStops[i + 2]); + } + cairo_set_source(context, pattern); + cairo_pattern_destroy(pattern); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(5); + return null; +} + +EXPORT(sqInt) primitiveFillRadialOriginXYdirectionXYnormalXYcolorStops(void) { + int*colorStops; + cairo_t*context; + sqInt colorStopsCount; + cairo_matrix_t*m; + cairo_matrix_t mdata; + sqInt i; + sqInt canvasOop; + cairo_pattern_t*pattern; + double ox; + double oy; + double dx; + double dy; + double nx; + double ny; + sqInt colorStopsOop; + + ox = interpreterProxy->stackFloatValue(6); + oy = interpreterProxy->stackFloatValue(5); + dx = interpreterProxy->stackFloatValue(4); + dy = interpreterProxy->stackFloatValue(3); + nx = interpreterProxy->stackFloatValue(2); + ny = interpreterProxy->stackFloatValue(1); + colorStopsOop = interpreterProxy->stackValue(0); + m = &mdata; + canvasOop = interpreterProxy->stackValue(7); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + colorStops = interpreterProxy->arrayValueOf(colorStopsOop); + colorStopsCount = interpreterProxy->slotSizeOf(colorStopsOop); + if (interpreterProxy->failed()) { + fail("bad colorStops array"); + return null; + } + pattern = cairo_pattern_create_radial(0.0, 0.0, 0.0, 0.0, 0.0, 1.0); + cairo_matrix_init(m, dx, dy, nx, ny, ox, oy); + cairo_matrix_invert(m); + cairo_pattern_set_matrix(pattern, m); + if (cairo_pattern_status(pattern)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_pattern_status(pattern))); + return null; + } + for (i = 0; i <= (colorStopsCount - 1); i += 3) { + addColorStopTooffsetrgbalpha(pattern, colorStops[i], colorStops[i + 1], colorStops[i + 2]); + } + cairo_set_source(context, pattern); + cairo_pattern_destroy(pattern); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(7); + return null; +} + +EXPORT(sqInt) primitiveFontFace(void) { + cairo_font_face_t*crFace; + FT_Face ftFace; + cairo_t*context; + sqInt canvasOop; + char *faceHandle; + + interpreterProxy->success(interpreterProxy->isBytes(interpreterProxy->stackValue(0))); + faceHandle = ((char *) (interpreterProxy->firstIndexableField(interpreterProxy->stackValue(0)))); + canvasOop = interpreterProxy->stackValue(1); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + ftFace = *(void**)faceHandle; + crFace = cairo_ft_font_face_create_for_ft_face(ftFace, FT_LOAD_NO_HINTING); + cairo_set_font_face(context, crFace); + cairo_font_face_destroy(crFace); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(1); + return null; +} + +EXPORT(sqInt) primitiveFontSize(void) { + cairo_t*context; + sqInt canvasOop; + double size; + + size = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(1); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_set_font_size(context, size); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(1); + return null; +} + +EXPORT(sqInt) primitiveGetLineWidth(void) { + double width; + cairo_t*context; + sqInt canvasOop; + sqInt _return_value; + + canvasOop = interpreterProxy->stackValue(0); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + width = cairo_get_line_width(context); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + _return_value = interpreterProxy->floatObjectOf(width); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(1, _return_value); + return null; +} + +EXPORT(sqInt) primitivePangoFontDescriptionIndex(void) { + sqInt familyNameSize; + sqInt newInd; + PangoFontDescription *desc; + sqInt i; + sqInt ind; + char cFamilyName[128]; + sqInt size; + sqInt pangoStyle; + char *familyName; + sqInt isAbsolute; + sqInt familyNameOop; + sqInt ptSize; + sqInt _return_value; + + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "Object")); + familyNameOop = interpreterProxy->stackValue(1); + ptSize = interpreterProxy->stackIntegerValue(0); + ; + if (interpreterProxy->failed()) { + return null; + } + if (interpreterProxy->failed()) { + return null; + } + familyNameSize = interpreterProxy->stSizeOf(familyNameOop); + if (familyNameSize > 127) { + return null; + } + if ((ptSize < 0) || (ptSize > 1000000)) { + _return_value = ((-1 << 1) | 1); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(3, _return_value); + return null; + } + familyName = interpreterProxy->firstIndexableField(familyNameOop); + for (i = 0; i <= (familyNameSize - 1); i += 1) { + cFamilyName[i] = (familyName[i]); + } + cFamilyName[familyNameSize] = 0; + newInd = -1; + ind = 0; + desc = null; + while (newInd == -1) { + desc = fontDescriptions[ind]; + if (desc == null) { + newInd = ind; + } else { + isAbsolute = pango_font_description_get_size_is_absolute(desc); + size = pango_font_description_get_size(desc); + if (isAbsolute) { + size = size; + } + if (((strcmp(cFamilyName, pango_font_description_get_family(desc))) == 0) && (size == (ptSize * (PANGO_SCALE)))) { + newInd = ind; + } + } + ind += 1; + if (ind > 255) { + newInd = 256; + } + } + if (newInd == 256) { + _return_value = ((-1 << 1) | 1); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(3, _return_value); + return null; + } + if (desc == null) { + null; + } else { + _return_value = ((newInd << 1) | 1); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(3, _return_value); + return null; + } + desc = pango_font_description_new(); + pango_font_description_set_family(desc, cFamilyName); + pangoStyle = PANGO_STYLE_NORMAL; + pango_font_description_set_style(desc, pangoStyle); + pango_font_description_set_size(desc, ptSize * (PANGO_SCALE)); + fontDescriptions[newInd] = desc; + _return_value = ((newInd << 1) | 1); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(3, _return_value); + return null; +} + +EXPORT(sqInt) primitiveGetTransform(void) { + cairo_t*context; + sqInt canvasOop; + cairo_matrix_t m; + float *aTransform; + + aTransform = ((float *) (interpreterProxy->arrayValueOf(interpreterProxy->stackValue(0)))); + canvasOop = interpreterProxy->stackValue(1); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_get_matrix(context, &m); + aTransform[0] = (m.xx); + aTransform[1] = (m.xy); + aTransform[2] = (m.x0); + aTransform[3] = (m.yx); + aTransform[4] = (m.yy); + aTransform[5] = (m.y0); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(1); + return null; +} + +EXPORT(sqInt) primitivePangoIndexAtPoint(void) { + sqInt index; + cairo_t*context; + sqInt origin; + unsigned char*aString; + sqInt trailing; + sqInt aStringOop; + sqInt lineIndex; + sqInt inside; + PangoAttrList*attrList; + PangoLayoutLine*line; + sqInt xPos; + PangoLayout*layout; + sqInt canvasOop; + sqInt corner; + sqInt charData; + PangoRectangle pos; + sqInt inStringOop; + sqInt x; + sqInt y; + sqInt sqAttrArray; + sqInt w; + sqInt h; + sqInt withWrap; + sqInt cData; + sqInt _return_value; + + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(7), "Object")); + inStringOop = interpreterProxy->stackValue(7); + x = interpreterProxy->stackIntegerValue(6); + y = interpreterProxy->stackIntegerValue(5); + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(4), "Object")); + sqAttrArray = interpreterProxy->stackValue(4); + w = interpreterProxy->stackIntegerValue(3); + h = interpreterProxy->stackIntegerValue(2); + withWrap = interpreterProxy->booleanValueOf(interpreterProxy->stackValue(1)); + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "Object")); + cData = interpreterProxy->stackValue(0); + ; + canvasOop = interpreterProxy->stackValue(8); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + aStringOop = inStringOop; + aString = interpreterProxy->firstIndexableField(aStringOop); + layout = pango_cairo_create_layout(context); + attrList = pango_attr_list_new(); + translateSqAttrsToPangoAttrsinto(sqAttrArray, attrList); + pango_layout_set_text(layout, aString, strlen(aString)); + pango_layout_set_attributes(layout, attrList); + pango_layout_set_width(layout, w * (PANGO_SCALE)); + if (withWrap) { + pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR); + } + cairo_translate(context, x, y); + pango_cairo_update_layout(context, layout); + inside = pango_layout_xy_to_index(layout, x * (PANGO_SCALE), y * (PANGO_SCALE), &index, &trailing); + pango_layout_index_to_pos(layout, index, &pos); + line = null; + if (!(inside)) { + pango_layout_index_to_line_x(layout, index, trailing, &lineIndex, &xPos); + + /* self log: 'lineIndex %x' with: line. */ + + line = pango_layout_get_line_readonly(layout, ((lineIndex < 0) ? 0 : lineIndex)); + if (line == null) { + index = strlen(aString); + } else { + pango_layout_line_ref(line); + + /* self log: 'line->length %d' with: (self cCode: 'line->length'). */ + + index = line->start_index; + index += line->length; + if (trailing > 0) { + trailing = 1; + } + } + } + pango_attr_list_unref(attrList); + g_object_unref(layout); + if (!(line == null)) { + pango_layout_line_unref(line); + } + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + interpreterProxy->pushRemappableOop(aStringOop); + interpreterProxy->pushRemappableOop(cData); + origin = interpreterProxy->makePointwithxValueyValue(PANGO_PIXELS(pos.x), PANGO_PIXELS(pos.y)); + interpreterProxy->pushRemappableOop(origin); + corner = interpreterProxy->makePointwithxValueyValue(PANGO_PIXELS(pos.x+pos.width), PANGO_PIXELS(pos.y+pos.height)); + origin = interpreterProxy->popRemappableOop(); + charData = interpreterProxy->popRemappableOop(); + aStringOop = interpreterProxy->popRemappableOop(); + aString = interpreterProxy->firstIndexableField(aStringOop); + interpreterProxy->storePointerofObjectwithValue(0, charData, origin); + interpreterProxy->storePointerofObjectwithValue(1, charData, corner); + index = sqCharCountInfromto(aString, 0, (((index + trailing) < (1 + (strlen(aString)))) ? (index + trailing) : (1 + (strlen(aString))))); + if (inside || (xPos <= 0)) { + index += 1; + } + interpreterProxy->storePointerofObjectwithValue(2, charData, ((index << 1) | 1)); + _return_value = interpreterProxy->integerObjectOf(index); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(9, _return_value); + return null; +} + +EXPORT(sqInt) primitiveLanguageAttributes(void) { + sqInt arraySize; + sqInt array4Oop; + sqInt lOop; + sqInt currentStart; + sqInt ws; + sqInt stringOop; + int *array; + int *array4; + unsigned int *string; + sqInt currentTag; + sqInt leadingChar; + sqInt arrayOop; + sqInt i; + sqInt arrayIndex; + sqInt stringSize; + sqInt currentEnd; + sqInt oStringOop; + sqInt oLOop; + sqInt oArrayOop; + sqInt _return_value; + sqInt v; + + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(2), "Object")); + oStringOop = interpreterProxy->stackValue(2); + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "Object")); + oLOop = interpreterProxy->stackValue(1); + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "Object")); + oArrayOop = interpreterProxy->stackValue(0); + if (interpreterProxy->failed()) { + return null; + } + if (interpreterProxy->failed()) { + return null; + } + lOop = oLOop; + arrayOop = oArrayOop; + stringOop = oStringOop; + if (interpreterProxy->isBytes(stringOop)) { + _return_value = interpreterProxy->integerObjectOf(0); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(4, _return_value); + return null; + } + if (!(interpreterProxy->isWords(stringOop))) { + primitiveFail(); + return null; + } + arraySize = interpreterProxy->stSizeOf(arrayOop); + if (arraySize <= 0) { + primitiveFail(); + return null; + } + stringSize = interpreterProxy->stSizeOf(stringOop); + if (stringSize == 0) { + _return_value = interpreterProxy->integerObjectOf(0); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(4, _return_value); + return null; + } + string = interpreterProxy->firstIndexableField(stringOop); + array = interpreterProxy->firstIndexableField(arrayOop); + ws = string[0]; + currentTag = ((usqInt) (ws & 1069547520) >> 22); + leadingChar = -1; + currentStart = 0; + /* begin utf8CountFor: */ + v = ws & 2097151; + if ((0 <= v) && (v <= 127)) { + currentEnd = 1; + goto l1; + } + if ((128 <= v) && (v <= 2047)) { + currentEnd = 2; + goto l1; + } + if ((2048 <= v) && (v <= 55295)) { + currentEnd = 3; + goto l1; + } + if ((57344 <= v) && (v <= 65535)) { + currentEnd = 3; + goto l1; + } + if ((65536 <= v) && (v <= 1114111)) { + currentEnd = 4; + goto l1; + } + currentEnd = 0; +l1: /* end utf8CountFor: */; + arrayIndex = 0; + for (i = 1; i <= (stringSize - 1); i += 1) { + ws = string[i]; + leadingChar = ((usqInt) (ws & 1069547520) >> 22); + if (leadingChar != currentTag) { + interpreterProxy->pushRemappableOop(stringOop); + interpreterProxy->pushRemappableOop(arrayOop); + interpreterProxy->pushRemappableOop(lOop); + array4Oop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classArray(), 4); + lOop = interpreterProxy->popRemappableOop(); + arrayOop = interpreterProxy->popRemappableOop(); + stringOop = interpreterProxy->popRemappableOop(); + array = interpreterProxy->firstIndexableField(arrayOop); + string = interpreterProxy->firstIndexableField(stringOop); + array4 = interpreterProxy->firstIndexableField(array4Oop); + array4[0] = lOop; + array4[1] = (((currentStart << 1) | 1)); + array4[2] = (((currentEnd << 1) | 1)); + array4[3] = (((currentTag << 1) | 1)); + array[arrayIndex] = array4Oop; + arrayIndex += 1; + if (arrayIndex >= arraySize) { + primitiveFail(); + return null; + } + currentTag = leadingChar; + currentStart = currentEnd; + } + currentEnd += utf8CountFor(ws); + } + interpreterProxy->pushRemappableOop(stringOop); + interpreterProxy->pushRemappableOop(arrayOop); + interpreterProxy->pushRemappableOop(lOop); + array4Oop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classArray(), 4); + lOop = interpreterProxy->popRemappableOop(); + arrayOop = interpreterProxy->popRemappableOop(); + stringOop = interpreterProxy->popRemappableOop(); + interpreterProxy->storePointerofObjectwithValue(0, array4Oop, lOop); + interpreterProxy->storeIntegerofObjectwithValue(1, array4Oop, currentStart); + interpreterProxy->storeIntegerofObjectwithValue(2, array4Oop, currentEnd); + interpreterProxy->storeIntegerofObjectwithValue(3, array4Oop, currentTag); + interpreterProxy->storePointerofObjectwithValue(arrayIndex, arrayOop, array4Oop); + arrayIndex += 1; + _return_value = interpreterProxy->integerObjectOf(arrayIndex); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(4, _return_value); + return null; +} + +EXPORT(sqInt) primitiveOpen(void) { + sqInt handleOop; + sqInt contextIndex; + sqInt canvasOop; + + canvasOop = interpreterProxy->stackValue(0); + if (interpreterProxy->failed()) { + return null; + } + contextIndex = createContextFor(canvasOop); + if (!(interpreterProxy->failed())) { + handleOop = interpreterProxy->integerObjectOf(contextIndex); + interpreterProxy->storePointerofObjectwithValue(CanvasHandleIndex, canvasOop, handleOop); + } + if (interpreterProxy->failed()) { + return null; + } + return null; +} + +EXPORT(sqInt) primitivePangoIsAvailable(void) { + PangoLayout*layout; + cairo_t*context; + sqInt canvasOop; + sqInt _return_value; + + canvasOop = interpreterProxy->stackValue(0); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + layout = pango_cairo_create_layout(context); + if (layout == null) { + _return_value = interpreterProxy->integerObjectOf(2); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(1, _return_value); + return null; + } + g_object_unref(layout); + _return_value = (1? interpreterProxy->trueObject(): interpreterProxy->falseObject()); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(1, _return_value); + return null; +} + +EXPORT(sqInt) primitivePluginVersion(void) { + sqInt _return_value; + + _return_value = interpreterProxy->integerObjectOf(PluginVersion); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(1, _return_value); + return null; +} + +EXPORT(sqInt) primitiveRestoreState(void) { + cairo_t*context; + sqInt canvasOop; + + canvasOop = interpreterProxy->stackValue(0); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_restore(context); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + return null; +} + +EXPORT(sqInt) primitiveRotateBy(void) { + cairo_t*context; + sqInt canvasOop; + double angle; + + angle = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(1); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_rotate(context, angle); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(1); + return null; +} + +EXPORT(sqInt) primitiveSaveState(void) { + cairo_t*context; + sqInt canvasOop; + + canvasOop = interpreterProxy->stackValue(0); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_save(context); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + return null; +} + +EXPORT(sqInt) primitiveScaleBy(void) { + cairo_t*context; + sqInt canvasOop; + double x; + double y; + + x = interpreterProxy->stackFloatValue(1); + y = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(2); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_scale(context, x, y); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(2); + return null; +} + +EXPORT(sqInt) primitiveSetLineWidth(void) { + cairo_t*context; + sqInt canvasOop; + double width; + + width = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(1); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_set_line_width(context, width); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(1); + return null; +} + +EXPORT(sqInt) primitiveSetTransform(void) { + cairo_t*context; + sqInt canvasOop; + cairo_matrix_t m; + float *aTransform; + + aTransform = ((float *) (interpreterProxy->arrayValueOf(interpreterProxy->stackValue(0)))); + canvasOop = interpreterProxy->stackValue(1); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_matrix_init(&m, aTransform[0], aTransform[3], aTransform[1], aTransform[4], aTransform[2], aTransform[5]); + cairo_set_matrix(context, &m); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(1); + return null; +} + +EXPORT(sqInt) primitivePangoShowString(void) { + cairo_t*context; + sqInt newW; + sqInt lineCount; + PangoRectangle ink; + unsigned int cursorColor; + PangoAttrList*attrList; + PangoLayoutLine*line; + PangoRectangle logical; + sqInt prevBaseline; + PangoLayout*layout; + PangoRectangle startRect; + sqInt canvasOop; + PangoLayoutIter*lineIter; + sqInt indexToX; + char *aString; + sqInt x; + sqInt y; + sqInt sqAttrArray; + sqInt w; + sqInt h; + sqInt withWrap; + sqInt selStart; + sqInt selEnd; + sqInt cPixel; + sqInt _return_value; + + interpreterProxy->success(interpreterProxy->isBytes(interpreterProxy->stackValue(9))); + aString = ((char *) (interpreterProxy->firstIndexableField(interpreterProxy->stackValue(9)))); + x = interpreterProxy->stackIntegerValue(8); + y = interpreterProxy->stackIntegerValue(7); + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(6), "Object")); + sqAttrArray = interpreterProxy->stackValue(6); + w = interpreterProxy->stackIntegerValue(5); + h = interpreterProxy->stackIntegerValue(4); + withWrap = interpreterProxy->booleanValueOf(interpreterProxy->stackValue(3)); + selStart = interpreterProxy->stackIntegerValue(2); + selEnd = interpreterProxy->stackIntegerValue(1); + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "Object")); + cPixel = interpreterProxy->stackValue(0); + ; + canvasOop = interpreterProxy->stackValue(10); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + cursorColor = interpreterProxy->positive32BitValueOf(cPixel); + if (interpreterProxy->failed()) { + return null; + } + layout = pango_cairo_create_layout(context); + attrList = pango_attr_list_new(); + translateSqAttrsToPangoAttrsinto(sqAttrArray, attrList); + if (!(selStart == selEnd)) { + if ((selStart >= 0) && (selEnd >= 0)) { + addSelectionFromtopixelinto(selStart, selEnd, cursorColor, attrList); + } + } + pango_layout_set_text(layout, aString, strlen(aString)); + pango_layout_set_attributes(layout, attrList); + pango_layout_set_width(layout, w * (PANGO_SCALE)); + if (withWrap) { + pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR); + } + cairo_translate(context, x, y); + pango_cairo_update_layout(context, layout); + + /* lineIter := self pangoLayoutGetIter: layout. + baseline := self pangoLayoutIterGetBaseline: lineIter. + prevBaseline := 0. + */ + + lineCount = pango_layout_get_line_count(layout); + if (1) { + pango_cairo_show_layout(context, layout); + } else { + null; + } + if (selStart == selEnd) { + if ((selStart >= 0) && (selEnd >= 0)) { + pango_layout_index_to_pos(layout, selStart, &startRect); + addSelectionAtpixelwith(&startRect, cursorColor, context); + } + } + pango_layout_get_extents(layout, &ink, &logical); + + /* self pangoLayoutIterFree: lineIter. */ + + newW = PANGO_PIXELS(logical.width); + pango_attr_list_unref(attrList); + g_object_unref(layout); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + _return_value = interpreterProxy->integerObjectOf(newW); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(11, _return_value); + return null; +} + + +/* Show a string - ignores outline (use drawString primitive for outlines) */ + +EXPORT(sqInt) primitiveShowZeroTerminatedUtf8StringXY(void) { + cairo_t*context; + sqInt canvasOop; + char *aString; + double x; + double y; + + interpreterProxy->success(interpreterProxy->isBytes(interpreterProxy->stackValue(2))); + aString = ((char *) (interpreterProxy->firstIndexableField(interpreterProxy->stackValue(2)))); + x = interpreterProxy->stackFloatValue(1); + y = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(3); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_move_to(context, x, y); + cairo_show_text(context, aString); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(3); + return null; +} + +EXPORT(sqInt) primitiveStencilImageSrcLRTBDestLRTB(void) { + cairo_surface_t*srcSurface; + cairo_t*context; + sqInt canvasOop; + sqInt formOop; + double dstL; + double dstR; + double dstT; + double dstB; + double srcL; + double srcR; + double srcT; + double srcB; + + formOop = interpreterProxy->stackValue(8); + dstL = interpreterProxy->stackFloatValue(7); + dstR = interpreterProxy->stackFloatValue(6); + dstT = interpreterProxy->stackFloatValue(5); + dstB = interpreterProxy->stackFloatValue(4); + srcL = interpreterProxy->stackFloatValue(3); + srcR = interpreterProxy->stackFloatValue(2); + srcT = interpreterProxy->stackFloatValue(1); + srcB = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(9); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + srcSurface = surfaceFrom(formOop); + if (!((srcSurface != null) && ((cairo_surface_status(srcSurface)) == 0))) { + fail("source surface invalid"); + return null; + } + if ((srcR != srcL) && (srcT != srcB)) { + cairo_save(context); + cairo_translate(context, dstL, dstT); + cairo_scale(context, (dstR - dstL) / (srcR - srcL), (dstB - dstT) / (srcB - srcT)); + cairo_new_path(context); + cairo_rectangle(context, 0.0, 0.0, srcR - srcL, srcB - srcT); + cairo_clip(context); + cairo_mask_surface(context, srcSurface, 0.0 - srcL, 0.0 - srcT); + cairo_restore(context); + } + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(9); + return null; +} + +EXPORT(sqInt) primitiveTransformBy(void) { + cairo_t*context; + sqInt canvasOop; + cairo_matrix_t m; + float *aTransform; + + aTransform = ((float *) (interpreterProxy->arrayValueOf(interpreterProxy->stackValue(0)))); + canvasOop = interpreterProxy->stackValue(1); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_matrix_init(&m, aTransform[0], aTransform[3], aTransform[1], aTransform[4], aTransform[2], aTransform[5]); + cairo_transform(context, &m); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(1); + return null; +} + +EXPORT(sqInt) primitiveTranslateBy(void) { + cairo_t*context; + sqInt canvasOop; + double x; + double y; + + x = interpreterProxy->stackFloatValue(1); + y = interpreterProxy->stackFloatValue(0); + canvasOop = interpreterProxy->stackValue(2); + if (interpreterProxy->failed()) { + return null; + } + context = contextFrom(canvasOop); + if (interpreterProxy->failed()) { + return null; + } + cairo_translate(context, x, y); + if (cairo_status(context)) { + failwith("cairo error: %s", cairo_status_to_string(cairo_status(context))); + return null; + } + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->pop(2); + return null; +} + +EXPORT(sqInt) primitiveUTF8StringWith2Indexes(void) { + sqInt utf8StringOop; + sqInt size; + sqInt bytes; + sqInt mult; + unsigned char *byteString; + sqInt stringOop; + sqInt utf8Index; + sqInt arrayOop; + sqInt i; + sqInt newIndex2; + sqInt realutf8StringOop; + sqInt newIndex1; + unsigned int *wideString; + unsigned char *realutf8String; + sqInt val; + unsigned int c; + unsigned char *utf8String; + sqInt oStringOop; + sqInt sqIndex1; + sqInt sqIndex2; + sqInt oArrayOop; + sqInt nullFlag; + + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(4), "Object")); + oStringOop = interpreterProxy->stackValue(4); + sqIndex1 = interpreterProxy->stackIntegerValue(3); + sqIndex2 = interpreterProxy->stackIntegerValue(2); + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "Object")); + oArrayOop = interpreterProxy->stackValue(1); + nullFlag = interpreterProxy->booleanValueOf(interpreterProxy->stackValue(0)); + if (interpreterProxy->failed()) { + return null; + } + if (interpreterProxy->failed()) { + return null; + } + arrayOop = oArrayOop; + stringOop = oStringOop; + if (interpreterProxy->isPointers(stringOop)) { + primitiveFail(); + return null; + } + bytes = interpreterProxy->isBytes(stringOop); + size = interpreterProxy->stSizeOf(stringOop); + if (bytes) { + mult = 2; + } else { + mult = 4; + } + interpreterProxy->pushRemappableOop(stringOop); + interpreterProxy->pushRemappableOop(arrayOop); + utf8StringOop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classString(), (size * mult) + 1); + arrayOop = interpreterProxy->popRemappableOop(); + stringOop = interpreterProxy->popRemappableOop(); + if (bytes) { + byteString = interpreterProxy->firstIndexableField(stringOop); + } else { + wideString = interpreterProxy->firstIndexableField(stringOop); + } + utf8Index = 0; + newIndex1 = -1; + newIndex2 = -1; + utf8String = interpreterProxy->firstIndexableField(utf8StringOop); + if (bytes) { + for (i = 0; i <= (size - 1); i += 1) { + c = byteString[i]; + if ((i + 1) == sqIndex1) { + newIndex1 = utf8Index; + } + if ((i + 1) == sqIndex2) { + newIndex2 = utf8Index; + } + utf8Index = putCharintoat(c, utf8String, utf8Index); + } + } else { + for (i = 0; i <= (size - 1); i += 1) { + c = wideString[i]; + if ((i + 1) == sqIndex1) { + newIndex1 = utf8Index; + } + if ((i + 1) == sqIndex2) { + newIndex2 = utf8Index; + } + utf8Index = putCharintoat(c, utf8String, utf8Index); + } + } + if (nullFlag) { + utf8String[utf8Index] = 0; + utf8Index += 1; + } + interpreterProxy->pushRemappableOop(utf8StringOop); + interpreterProxy->pushRemappableOop(arrayOop); + realutf8StringOop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classString(), utf8Index); + arrayOop = interpreterProxy->popRemappableOop(); + utf8StringOop = interpreterProxy->popRemappableOop(); + utf8String = interpreterProxy->firstIndexableField(utf8StringOop); + realutf8String = interpreterProxy->firstIndexableField(realutf8StringOop); + memcpy(realutf8String, utf8String, utf8Index); + interpreterProxy->storePointerofObjectwithValue(0, arrayOop, realutf8StringOop); + if (newIndex1 == -1) { + if (sqIndex1 == -1) { + val = -1; + } else { + val = utf8Index; + } + } else { + val = newIndex1; + } + interpreterProxy->storeIntegerofObjectwithValue(1, arrayOop, val); + if (newIndex2 == -1) { + if (sqIndex2 == -1) { + val = -1; + } else { + val = utf8Index; + } + } else { + val = newIndex2; + } + interpreterProxy->storeIntegerofObjectwithValue(2, arrayOop, val); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(6, arrayOop); + return null; +} + +EXPORT(sqInt) primitiveUTF8StringWithIndex(void) { + sqInt utf8StringOop; + sqInt size; + sqInt bytes; + sqInt mult; + unsigned char *byteString; + sqInt stringOop; + sqInt utf8Index; + sqInt arrayOop; + sqInt i; + sqInt realutf8StringOop; + unsigned int *wideString; + unsigned char *realutf8String; + sqInt val; + unsigned int c; + sqInt newIndex; + unsigned char *utf8String; + sqInt oStringOop; + sqInt sqIndex; + sqInt oArrayOop; + sqInt nullFlag; + + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(3), "Object")); + oStringOop = interpreterProxy->stackValue(3); + sqIndex = interpreterProxy->stackIntegerValue(2); + interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "Object")); + oArrayOop = interpreterProxy->stackValue(1); + nullFlag = interpreterProxy->booleanValueOf(interpreterProxy->stackValue(0)); + if (interpreterProxy->failed()) { + return null; + } + if (interpreterProxy->failed()) { + return null; + } + arrayOop = oArrayOop; + stringOop = oStringOop; + if (interpreterProxy->isPointers(stringOop)) { + primitiveFail(); + return null; + } + bytes = interpreterProxy->isBytes(stringOop); + size = interpreterProxy->stSizeOf(stringOop); + if (bytes) { + mult = 2; + } else { + mult = 4; + } + interpreterProxy->pushRemappableOop(stringOop); + interpreterProxy->pushRemappableOop(arrayOop); + utf8StringOop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classString(), (size * mult) + 1); + arrayOop = interpreterProxy->popRemappableOop(); + stringOop = interpreterProxy->popRemappableOop(); + if (bytes) { + byteString = interpreterProxy->firstIndexableField(stringOop); + } else { + wideString = interpreterProxy->firstIndexableField(stringOop); + } + utf8Index = 0; + newIndex = -1; + utf8String = interpreterProxy->firstIndexableField(utf8StringOop); + if (bytes) { + for (i = 0; i <= (size - 1); i += 1) { + c = byteString[i]; + if ((i + 1) == sqIndex) { + newIndex = utf8Index; + } + utf8Index = putCharintoat(c, utf8String, utf8Index); + } + } else { + for (i = 0; i <= (size - 1); i += 1) { + c = wideString[i]; + if ((i + 1) == sqIndex) { + newIndex = utf8Index; + } + utf8Index = putCharintoat(c, utf8String, utf8Index); + } + } + if (nullFlag) { + utf8String[utf8Index] = 0; + utf8Index += 1; + } + interpreterProxy->pushRemappableOop(utf8StringOop); + interpreterProxy->pushRemappableOop(arrayOop); + realutf8StringOop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classString(), utf8Index); + arrayOop = interpreterProxy->popRemappableOop(); + utf8StringOop = interpreterProxy->popRemappableOop(); + utf8String = interpreterProxy->firstIndexableField(utf8StringOop); + realutf8String = interpreterProxy->firstIndexableField(realutf8StringOop); + memcpy(realutf8String, utf8String, utf8Index); + interpreterProxy->storePointerofObjectwithValue(0, arrayOop, realutf8StringOop); + if (newIndex == -1) { + if (sqIndex == -1) { + val = -1; + } else { + val = utf8Index; + } + } else { + val = newIndex; + } + interpreterProxy->storeIntegerofObjectwithValue(1, arrayOop, val); + if (interpreterProxy->failed()) { + return null; + } + interpreterProxy->popthenPush(5, arrayOop); + return null; +} + +static sqInt putCharintoat(sqInt c, unsigned char*utf8String, sqInt utf8Index) { + unsigned int val; + sqInt nBytes; + sqInt mask; + sqInt i; + sqInt index; + sqInt shift; + sqInt v; + + val = c & 2097151; + index = utf8Index; + if ((0 <= val) && (val <= 127)) { + utf8String[index] = val; + return utf8Index + 1; + } + /* begin utf8CountFor: */ + v = c & 2097151; + if ((0 <= v) && (v <= 127)) { + nBytes = 1; + goto l1; + } + if ((128 <= v) && (v <= 2047)) { + nBytes = 2; + goto l1; + } + if ((2048 <= v) && (v <= 55295)) { + nBytes = 3; + goto l1; + } + if ((57344 <= v) && (v <= 65535)) { + nBytes = 3; + goto l1; + } + if ((65536 <= v) && (v <= 1114111)) { + nBytes = 4; + goto l1; + } + nBytes = 0; +l1: /* end utf8CountFor: */; + mask = utf8Headers[nBytes - 1]; + shift = (nBytes - 1) * -6; + utf8String[index] = ((((shift < 0) ? ((usqInt) val >> -shift) : ((usqInt) val << shift))) | mask); + index += 1; + for (i = 2; i <= nBytes; i += 1) { + shift += 6; + utf8String[index] = (((((shift < 0) ? ((usqInt) val >> -shift) : ((usqInt) val << shift))) & 63) + 128); + index += 1; + } + return utf8Index + nBytes; +} + + +/* Register the given surface, answer an ID or -1 on failure */ + +static sqInt registerSurface(cairo_surface_t*surfaceHandle) { + sqInt surfaceID; + + if (registerSurfaceFn == null) { + if (!(loadSurfacePlugin())) { + return -1; + } + } + if (!((*registerSurfaceFn)((int)surfaceHandle, &surfaceDispatch, &surfaceID))) { + fail("could not register surface"); + return -1; + } + /* missing DebugCode */; + if (surfaceID > maxSurfaceID) { + maxSurfaceID = surfaceID; + } + return surfaceID; +} + + +/* Note: This is coded so that is can be run from Squeak. */ + +EXPORT(sqInt) setInterpreter(struct VirtualMachine*anInterpreter) { + sqInt ok; + + interpreterProxy = anInterpreter; + ok = interpreterProxy->majorVersion() == VM_PROXY_MAJOR; + if (ok == 0) { + return 0; + } + ok = interpreterProxy->minorVersion() >= VM_PROXY_MINOR; + return ok; +} + +static void setSourcergbalpha(cairo_t*context, sqInt rgb, sqInt alpha) { + sqInt b; + sqInt r; + sqInt g; + + r = (((usqInt) rgb) >> 20) & 1023; + g = (((usqInt) rgb) >> 10) & 1023; + b = (((usqInt) rgb) >> 0) & 1023; + if (alpha == 255) { + cairo_set_source_rgb(context, r / 1023.0, g / 1023.0, b / 1023.0); + } else { + cairo_set_source_rgba(context, r / 1023.0, g / 1023.0, b / 1023.0, alpha / 255.0); + } +} + +static sqInt showSurfacexywh(cairo_surface_t *surfaceHandle, sqInt x, sqInt y, sqInt w, sqInt h) { + return 0; +} + +EXPORT(sqInt) shutdownModule(void) { + PangoFontDescription*desc; + sqInt i; + sqInt id; + cairo_surface_t*surface; + + for (i = 0; i <= (lastIndex(contexts)); i += 1) { + if (!((contexts[i]) == null)) { + logwith("context %i still active when unloading module!", i); + cairo_destroy(contexts[i]); + contexts[i] = null; + } + } + for (id = 0; id <= maxSurfaceID; id += 1) { + surface = findSurface(id); + if (surface != null) { + logwith("surface %i still active when unloading module!", id); + destroySurface(id); + } + } + for (i = 0; i <= 255; i += 1) { + desc = fontDescriptions[i]; + if (desc != null) { + pango_font_description_free(desc); + fontDescriptions[i] = null; + } + } + if (defaultFontDescription != null) { + pango_font_description_free(defaultFontDescription); + defaultFontDescription = null; + } + return 1; +} + +static sqInt sqAssert(sqInt aBool) { + /* missing DebugCode */; +} + +static sqInt sqCharCountInfromto(unsigned char* aString, sqInt from, sqInt to) { + sqInt sqCount; + sqInt aChar; + sqInt index; + + index = from; + sqCount = 0; + while (index < to) { + aChar = aString[index]; + if (aChar < 128) { + index += 1; + } else { + if (aChar < 224) { + index += 2; + } else { + if (aChar < 240) { + index += 3; + } else { + if (aChar < 248) { + index += 4; + } else { + if (aChar < 252) { + index += 5; + } else { + if (aChar >= 252) { + index += 6; + } + } + } + } + } + } + sqCount += 1; + } + return sqCount; +} + + +/* stroke depending on canvasOop's stroke flag */ + +static void strokefrom(cairo_t*context, sqInt canvasOop) { + sqInt stroke; + sqInt canvasFlags; + sqInt rgb; + + canvasFlags = interpreterProxy->fetchIntegerofObject(CanvasFlagsIndex, canvasOop); + if (interpreterProxy->failed()) { + fail("canvas flags not an integer"); + } else { + stroke = canvasFlags & CanvasFlagStroke; + if (stroke != 0) { + rgb = interpreterProxy->fetchIntegerofObject(CanvasStrokeColorIndex, canvasOop); + cairo_save(context); + setSourcergbalpha(context, rgb, stroke); + cairo_stroke(context); + cairo_restore(context); + } + } +} + + +/* answer a surface by looking up its surface plugin ID stored as bits in formOop */ + +static cairo_surface_t* surfaceFrom(sqInt formOop) { + sqInt surfaceID; + + if ((interpreterProxy->slotSizeOf(formOop)) < FormInstSize) { + fail("form oop invalid"); + return null; + } + surfaceID = interpreterProxy->fetchIntegerofObject(FormBitsIndex, formOop); + if (interpreterProxy->failed()) { + fail("form handle not an integer"); + return null; + } + return findSurface(surfaceID); +} + +static sqInt translateSqAttrsToPangoAttrsinto(sqInt sqAttrsArrayOop, PangoAttrList *pangoAttrList) { + sqInt ind; + sqInt symbolOop; + sqInt *sqAttrsArray; + char *symbol; + sqInt sqAttrsSize; + sqInt attrArray; + + sqAttrsSize = interpreterProxy->stSizeOf(sqAttrsArrayOop); + sqAttrsArray = interpreterProxy->firstIndexableField(sqAttrsArrayOop); + addDefaultInto(pangoAttrList); + for (ind = 0; ind <= (sqAttrsSize - 1); ind += 1) { + attrArray = sqAttrsArray[ind]; + symbolOop = interpreterProxy->fetchPointerofObject(0, attrArray); + symbol = interpreterProxy->firstIndexableField(symbolOop); + if ((symbol[0]) == 65) { + addAlignmentinto(attrArray, pangoAttrList); + } + if ((symbol[0]) == 67) { + addColorinto(attrArray, pangoAttrList); + } + if ((symbol[0]) == 69) { + addEmphasisinto(attrArray, pangoAttrList); + } + if ((symbol[0]) == 70) { + addFontinto(attrArray, pangoAttrList); + } + if ((symbol[0]) == 76) { + addLanguageinto(attrArray, pangoAttrList); + } + } + return 1; +} + +static sqInt unlockSurfacexywh(cairo_surface_t*surfaceHandle, sqInt x, sqInt y, sqInt w, sqInt h) { + /* missing DebugCode */; + if ((w > 0) && (h > 0)) { + cairo_surface_mark_dirty_rectangle(surfaceHandle, x, y, w, h); + } + return 1; +} + + +/* Unregister the surface, answer true if successful */ + +static sqInt unregisterSurface(sqInt surfaceID) { + if (unregisterSurfaceFn == null) { + if (!(loadSurfacePlugin())) { + return 0; + } + } + /* missing DebugCode */; + if (!((*unregisterSurfaceFn)(surfaceID))) { + failwith("could not unregister surface %i", surfaceID); + return 0; + } + return 1; +} + +static sqInt utf8CountFor(unsigned int value) { + sqInt v; + + v = value & 2097151; + if ((0 <= v) && (v <= 127)) { + return 1; + } + if ((128 <= v) && (v <= 2047)) { + return 2; + } + if ((2048 <= v) && (v <= 55295)) { + return 3; + } + if ((57344 <= v) && (v <= 65535)) { + return 3; + } + if ((65536 <= v) && (v <= 1114111)) { + return 4; + } + return 0; +} + + +#ifdef SQUEAK_BUILTIN_PLUGIN + + +void* RomePlugin_exports[][3] = { + {"RomePlugin", "primitivePangoBlockAtIndex", (void*)primitivePangoBlockAtIndex}, + {"RomePlugin", "primitiveDrawImageSrcLRTBDestLRTB", (void*)primitiveDrawImageSrcLRTBDestLRTB}, + {"RomePlugin", "primitiveDrawGeneralBezierShape", (void*)primitiveDrawGeneralBezierShape}, + {"RomePlugin", "initialiseModule", (void*)initialiseModule}, + {"RomePlugin", "primitiveFillRadialOriginXYdirectionXYnormalXYcolorStops", (void*)primitiveFillRadialOriginXYdirectionXYnormalXYcolorStops}, + {"RomePlugin", "primitiveFillColorAlpha", (void*)primitiveFillColorAlpha}, + {"RomePlugin", "primitiveFillLinearOriginXYdirectionXYcolorStops", (void*)primitiveFillLinearOriginXYdirectionXYcolorStops}, + {"RomePlugin", "primitiveDestroyFormHandle", (void*)primitiveDestroyFormHandle}, + {"RomePlugin", "primitiveClear", (void*)primitiveClear}, + {"RomePlugin", "primitiveTransformBy", (void*)primitiveTransformBy}, + {"RomePlugin", "primitiveDrawOvalLeftRightTopBottom", (void*)primitiveDrawOvalLeftRightTopBottom}, + {"RomePlugin", "primitiveDrawPolygon", (void*)primitiveDrawPolygon}, + {"RomePlugin", "primitivePluginVersion", (void*)primitivePluginVersion}, + {"RomePlugin", "primitiveShowZeroTerminatedUtf8StringXY", (void*)primitiveShowZeroTerminatedUtf8StringXY}, + {"RomePlugin", "primitiveFontFace", (void*)primitiveFontFace}, + {"RomePlugin", "primitiveClipRectangleLeftRightTopBottom", (void*)primitiveClipRectangleLeftRightTopBottom}, + {"RomePlugin", "getModuleName", (void*)getModuleName}, + {"RomePlugin", "primitiveFontSize", (void*)primitiveFontSize}, + {"RomePlugin", "primitivePangoIndexAtPoint", (void*)primitivePangoIndexAtPoint}, + {"RomePlugin", "primitiveDrawPolyline", (void*)primitiveDrawPolyline}, + {"RomePlugin", "primitiveDrawCurveFromXYviaXYandXYtoXY", (void*)primitiveDrawCurveFromXYviaXYandXYtoXY}, + {"RomePlugin", "primitiveRotateBy", (void*)primitiveRotateBy}, + {"RomePlugin", "primitiveDrawRoundRectLeftRightTopBottomRadiusCorner", (void*)primitiveDrawRoundRectLeftRightTopBottomRadiusCorner}, + {"RomePlugin", "moduleUnloaded", (void*)moduleUnloaded}, + {"RomePlugin", "primitiveDrawLineFromXYtoXY", (void*)primitiveDrawLineFromXYtoXY}, + {"RomePlugin", "primitivePangoShowString", (void*)primitivePangoShowString}, + {"RomePlugin", "primitiveDrawArcRadiusXYFromTo", (void*)primitiveDrawArcRadiusXYFromTo}, + {"RomePlugin", "primitiveDrawZeroTerminatedUtf8StringXY", (void*)primitiveDrawZeroTerminatedUtf8StringXY}, + {"RomePlugin", "primitiveSetLineWidth", (void*)primitiveSetLineWidth}, + {"RomePlugin", "primitivePangoComposeString", (void*)primitivePangoComposeString}, + {"RomePlugin", "primitiveUTF8StringWithIndex", (void*)primitiveUTF8StringWithIndex}, + {"RomePlugin", "primitiveStencilImageSrcLRTBDestLRTB", (void*)primitiveStencilImageSrcLRTBDestLRTB}, + {"RomePlugin", "setInterpreter", (void*)setInterpreter}, + {"RomePlugin", "primitiveRestoreState", (void*)primitiveRestoreState}, + {"RomePlugin", "primitiveScaleBy", (void*)primitiveScaleBy}, + {"RomePlugin", "primitivePangoComposeString2", (void*)primitivePangoComposeString2}, + {"RomePlugin", "primitiveDrawRectangleLeftRightTopBottom", (void*)primitiveDrawRectangleLeftRightTopBottom}, + {"RomePlugin", "primitiveFillBitmapOriginXYdirectionXYnormalXYRepeatImage", (void*)primitiveFillBitmapOriginXYdirectionXYnormalXYRepeatImage}, + {"RomePlugin", "primitiveSetTransform", (void*)primitiveSetTransform}, + {"RomePlugin", "primitiveSaveState", (void*)primitiveSaveState}, + {"RomePlugin", "primitiveLanguageAttributes", (void*)primitiveLanguageAttributes}, + {"RomePlugin", "primitiveGetTransform", (void*)primitiveGetTransform}, + {"RomePlugin", "primitivePangoFontDescriptionIndex", (void*)primitivePangoFontDescriptionIndex}, + {"RomePlugin", "primitiveUTF8StringWith2Indexes", (void*)primitiveUTF8StringWith2Indexes}, + {"RomePlugin", "primitiveCreateFormHandle", (void*)primitiveCreateFormHandle}, + {"RomePlugin", "primitivePangoIsAvailable", (void*)primitivePangoIsAvailable}, + {"RomePlugin", "primitiveClose", (void*)primitiveClose}, + {"RomePlugin", "primitiveOpen", (void*)primitiveOpen}, + {"RomePlugin", "primitiveDrawCurveFromXYviaXYtoXY", (void*)primitiveDrawCurveFromXYviaXYtoXY}, + {"RomePlugin", "primitiveGetLineWidth", (void*)primitiveGetLineWidth}, + {"RomePlugin", "shutdownModule", (void*)shutdownModule}, + {"RomePlugin", "primitiveTranslateBy", (void*)primitiveTranslateBy}, + {NULL, NULL, NULL} +}; + + +#endif /* ifdef SQ_BUILTIN_PLUGIN */ + Added: trunk/platforms/unix/src/plugins/Squeak3D/Squeak3D.c =================================================================== --- trunk/platforms/unix/src/plugins/Squeak3D/Squeak3D.c (rev 0) +++ trunk/platforms/unix/src/plugins/Squeak3D/Squeak3D.c 2011-01-23 09:41:21 UTC (rev 2355) @@ -0,0 +1,3087 @@ +/* Automatically generated from Squeak on 23 January 2011 6:34:03 pm + by VMMaker 4.4.7 + */ + +#include <math.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> + +/* Default EXPORT macro that does nothing (see comment in sq.h): */ +#define EXPORT(returnType) returnType + +/* Do not include the entire sq.h file but just those parts needed. */ +/* The virtual machine proxy definition */ +#include "sqVirtualMachine.h" +/* Configuration options */ +#include "sqConfig.h" +/* Platform specific definitions */ +#include "sqPlatformSpecific.h" + +#define true 1 +#define false 0 +#define null 0 /* using 'null' because nil is predefined in Think C */ +#ifdef SQUEAK_BUILTIN_PLUGIN +#undef EXPORT +// was #undef EXPORT(returnType) but screws NorCroft cc +#define EXPORT(returnType) static returnType +#endif +#include "b3d.h" +#include "b3d.h" + +#include "sqMemoryAccess.h" + + +/*** Constants ***/ +#define AmbientPart 0 +#define DiffusePart 4 +#define EmissionAlpha 15 +#define EmissionBlue 14 +#define EmissionGreen 13 +#define EmissionRed 12 +#define FlagAmbientPart 256 +#define FlagAttenuated 4 +#define FlagDiffusePart 512 +#define FlagDirectional 2 +#define FlagHasSpot 8 +#define FlagM44Identity 1 +#define FlagM44NoPerspective 2 +#define FlagM44NoTranslation 4 +#define FlagPositional 1 +#define FlagSpecularPart 1024 +#define InAllMask 1365 +#define InBackBit 1024 +#define InBottomBit 64 +#define InFrontBit 256 +#define InLeftBit 1 +#define InRightBit 4 +#define InTopBit 16 +#define MaterialShininess 16 +#define MaterialSize 17 +#define OutAllMask 2730 +#define OutBackBit 2048 +#define OutBottomBit 128 +#define OutFrontBit 512 +#define OutLeftBit 2 +#define OutRightBit 8 +#define OutTopBit 32 +#define PrimLightAttenuationConstant 18 +#define PrimLightAttenuationLinear 19 +#define PrimLightAttenuationSquared 20 +#define PrimLightDirection 15 +#define PrimLightDirectionX 15 +#define PrimLightDirectionY 16 +#define PrimLightDirectionZ 17 +#define PrimLightFlags 21 +#define PrimLightPositionX 12 +#define PrimLightPositionY 13 +#define PrimLightPositionZ 14 +#define PrimLightSize 32 +#define PrimTypeMax 6 +#define PrimVertexSize 16 +#define PrimVtxClipFlags 13 +#define PrimVtxColor32 12 +#define PrimVtxNormal 3 +#define PrimVtxNormalX 3 +#define PrimVtxNormalY 4 +#define PrimVtxNormalZ 5 +#define PrimVtxPosition 0 +#define PrimVtxPositionX 0 +#define PrimVtxPositionY 1 +#define PrimVtxPositionZ 2 +#define PrimVtxRasterPosW 11 +#define PrimVtxRasterPosX 8 +#define PrimVtxRasterPosY 9 +#define PrimVtxRasterPosZ 10 +#define PrimVtxTexCoordU 6 +#define PrimVtxTexCoordV 7 +#define PrimVtxTexCoords 6 +#define SpecularPart 8 +#define SpotLightDeltaCos 24 +#define SpotLightExponent 25 +#define SpotLightMinCos 22 +#define VBTrackAmbient 1 +#define VBTrackDiffuse 2 +#define VBTrackEmission 8 +#define VBTrackSpecular 4 +#define VBTwoSidedLighting 64 +#define VBUseLocalViewer 128 +#define VBVtxHasNormals 16 + +/*** Function Prototypes ***/ +static sqInt addPartfromtrackFlagscale(float *lightPart, float *materialPart, sqInt vbTrackFlag, double scale); +static sqInt analyzeMatrix3x3Length(float *m); +static sqInt analyzeMatrix(float *m); +#pragma export on +EXPORT(sqInt) b3dClipPolygon(void); +EXPORT(sqInt) b3dComputeMinIndexZ(void); +EXPORT(sqInt) b3dComputeMinZ(void); +EXPORT(sqInt) b3dDetermineClipFlags(void); +EXPORT(sqInt) b3dInitPrimitiveObject(void); +EXPORT(sqInt) b3dInitializeRasterizerState(void); +EXPORT(sqInt) b3dInplaceHouseHolderInvert(void); +EXPORT(sqInt) b3dLoadIndexArray(void); +EXPORT(sqInt) b3dLoadVertexBuffer(void); +EXPORT(sqInt) b3dMapVertexBuffer(void); +EXPORT(sqInt) b3dOrthoNormInverseMatrix(void); +EXPORT(sqInt) b3dPrimitiveNextClippedTriangle(void); +EXPORT(sqInt) b3dPrimitiveObjectSize(void); +EXPORT(sqInt) b3dPrimitiveTextureSize(void); +EXPORT(sqInt) b3dRasterizerVersion(void); +EXPORT(sqInt) b3dShadeVertexBuffer(void); +EXPORT(sqInt) b3dShaderVersion(void); +EXPORT(sqInt) b3dStartRasterizer(void); +EXPORT(sqInt) b3dTransformDirection(void); +EXPORT(sqInt) b3dTransformMatrixWithInto(void); +EXPORT(sqInt) b3dTransformPoint(void); +EXPORT(sqInt) b3dTransformPrimitiveNormal(void); +EXPORT(sqInt) b3dTransformPrimitivePosition(void); +EXPORT(sqInt) b3dTransformPrimitiveRasterPosition(void); +EXPORT(sqInt) b3dTransformVertexBuffer(void); +EXPORT(sqInt) b3dTransformerVersion(void); +EXPORT(sqInt) b3dTransposeMatrix(void); +#pragma export off +static double backClipValueFromto(sqInt last, sqInt next); +static double bottomClipValueFromto(sqInt last, sqInt next); +static sqInt clipPolygoncountwithmask(int *vtxArray, sqInt vtxCount, int *tempVtxArray, sqInt outMask); +static sqInt clipPolygonBackFromtocount(int *buf1, int *buf2, sqInt n); +static sqInt clipPolygonBottomFromtocount(int *buf1, int *buf2, sqInt n); +static sqInt clipPolygonFrontFromtocount(int *buf1, int *buf2, sqInt n); +static sqInt clipPolygonLeftFromtocount(int *buf1, int *buf2, sqInt n); +static sqInt clipPolygonRightFromtocount(int *buf1, int *buf2, sqInt n); +static sqInt clipPolygonTopFromtocount(int *buf1, int *buf2, sqInt n); +static sqInt computeAttenuation(void); +static sqInt computeDirection(void); +static sqInt computeSpecularDirection(void); +static double computeSpotFactor(void); +static sqInt determineClipFlagscount(void *vtxArray, sqInt count); +static double dotProductOfFloatwithDouble(float * v1, double *v2); +static void* fetchLightSourceofObject(sqInt index, sqInt anArray); +static double frontClipValueFromto(sqInt last, sqInt next); +static VirtualMachine * getInterpreter(void); +#pragma export on +EXPORT(const char*) getModuleName(void); +#pragma export off +static sqInt halt(void); +#pragma export on +EXPORT(sqInt) initialiseModule(void); +#pragma export off +static sqInt interpolateFromtoatinto(float *last, float *next, double t, float *out); +static double inverseLengthOfDouble(double * aVector); +static double inverseLengthOfFloat(float * aVector); +static double leftClipValueFromto(sqInt last, sqInt next); +static sqInt loadObjectsFrom(sqInt stackIndex); +static sqInt loadPrimitiveLightSource(void); +static sqInt loadPrimitiveVertex(void); +static sqInt loadRasterizerState(sqInt stackIndex); +static sqInt loadTextureinto(sqInt textureOop, B3DTexture *destPtr); +static sqInt loadTexturesFrom(sqInt stackIndex); +static sqInt loadViewportFrom(sqInt stackIndex); +static sqInt mapVBofSizeinto(void *vtxArray, sqInt vtxCount, sqInt boxArray); +#pragma export on +EXPORT(sqInt) moduleUnloaded(char *aModuleName); +#pragma export off +static sqInt msg(char *s); +#pragma export on +EXPORT(sqInt) primitiveSetBitBltPlugin(void); +#pragma export off +static double processIndexedofSizeidxArrayidxSize(float *vtxArray, sqInt vtxSize, int *idxArray, sqInt idxSize); +static sqInt processIndexedIDXofSizeidxArrayidxSize(float *vtxArray, sqInt vtxSize, int *idxArray, sqInt idxSize); +static double processNonIndexedofSize(float *vtxArray, sqInt vtxSize); +static sqInt processNonIndexedIDXofSize(float *vtxArray, sqInt vtxSize); +static double rightClipValueFromto(sqInt last, sqInt next); +#pragma export on +EXPORT(sqInt) setInterpreter(struct VirtualMachine*anInterpreter); +#pragma export off +static sqInt shadeVertex(void); +static sqInt stackLightArrayValue(sqInt stackIndex); +static void * stackMaterialValue(sqInt stackIndex); +static void* stackMatrix(sqInt index); +static void* stackPrimitiveIndexArrayofSizevalidateforVertexSize(sqInt stackIndex, sqInt nItems, sqInt aBool, sqInt maxIndex); +static void* stackPrimitiveVertex(sqInt index); +static void* stackPrimitiveVertexArrayofSize(sqInt index, sqInt nItems); +static sqInt storeObjectsInto(sqInt stackIndex); +static sqInt storePrimitiveVertex(void); +static double topClipValueFromto(sqInt last, sqInt next); +static sqInt transformMatrixwithinto(float *src, float *arg, float *dst); +static sqInt transformPrimitiveNormalbyrescale(float *pVertex, float *matrix, sqInt rescale); +static sqInt transformPrimitivePositionby(float *pVertex, float *matrix); +static sqInt transformPrimitivePositionFastby(float *pVertex, float *matrix); +static sqInt transformPrimitivePositionFasterby(float *pVertex, float *matrix); +static sqInt transformPrimitiveRasterPositionby(float *pVertex, float *matrix); +static sqInt transformVBcountbyandflags(float *vtxArray, sqInt vtxCount, float *modelViewMatrix, float *projectionMatrix, sqInt flags); +static void* vbLoadArraysize(sqInt oop, sqInt count); +/*** Variables ***/ +static char bbPluginName[256] = "BitBltPlugin"; +static sqInt copyBitsFn; + +#ifdef SQUEAK_BUILTIN_PLUGIN +extern +#endif +struct VirtualMachine* interpreterProxy; +static double l2vDirection[3]; +static double l2vDistance; +static double l2vSpecDir[3]; +static sqInt lightFlags; +static double lightScale; +static float* litVertex; +static sqInt loadBBFn; +static const char *moduleName = +#ifdef SQUEAK_BUILTIN_PLUGIN + "Squeak3D 23 January 2011 (i)" +#else + "Squeak3D 23 January 2011 (e)" +#endif +; +static float* primLight; +static float* primMaterial; +static B3DRasterizerState state; +static sqInt vbFlags; +static B3DPrimitiveViewport viewport; +static double vtxInColor[4]; +static double vtxOutColor[4]; + + + +/* Add the given light part to the output color, scaled by the given scale factor. + If the given flag is set in vbFlags then load the part from the primitive vertex */ + +static sqInt addPartfromtrackFlagscale(float *lightPart, float *materialPart, sqInt vbTrackFlag, double scale) { + double aPart; + double bPart; + double gPart; + double rPart; + + if (vbFlags & vbTrackFlag) { + rPart = ((vtxInColor[0]) * (lightPart[0])) * scale; + gPart = ((vtxInColor[1]) * (lightPart[1])) * scale; + bPart = ((vtxInColor[2]) * (lightPart[2])) * scale; + aPart = ((vtxInColor[3]) * (lightPart[3])) * scale; + } else { + + /* Note: This should be pre-computed. */ + + rPart = ((materialPart[0]) * (lightPart[0])) * scale; + gPart = ((materialPart[1]) * (lightPart[1])) * scale; + bPart = ((materialPart[2]) * (lightPart[2])) * scale; + aPart = ((materialPart[3]) * (lightPart[3])) * scale; + } + vtxOutColor[0] = ((vtxOutColor[0]) + rPart); + vtxOutColor[1] = ((vtxOutColor[1]) + gPart); + vtxOutColor[2] = ((vtxOutColor[2]) + bPart); + vtxOutColor[3] = ((vtxOutColor[3]) + aPart); +} + + +/* Check if the matrix scales normals to non-unit length. */ + +static sqInt analyzeMatrix3x3Length(float *m) { + double det; + + det = (((((((m[0]) * (m[5])) * (m[10])) - (((m[2]) * (m[5])) * (m[8]))) + (((m[4]) * (m[9])) * (m[2]))) - (((m[6]) * (m[9])) * (m[0]))) + (((m[8]) * (m[1])) * (m[6]))) - (((m[10]) * (m[1])) * (m[4])); + return (det < 0.99) || (det > 1.01); +} + + +/* Analyze the matrix and return the appropriate flags */ + +static sqInt analyzeMatrix(float *m) { + sqInt flags; + + flags = 0; + if (((m[12]) == 0.0) && (((m[13]) == 0.0) && (((m[14]) == 0.0) && ((m[15]) == 1.0)))) { + + /* Check translation */ + + flags = flags | FlagM44NoPerspective; + if (((m[3]) == 0.0) && (((m[7]) == 0.0) && ((m[11]) == 0.0))) { + + /* Check for identity */ + + flags = flags | FlagM44NoTranslation; + if (((m[0]) == 1.0) && (((m[5]) == 1.0) && (((m[10]) == 1.0) && (((m[1]) == 0.0) && (((m[2]) == 0.0) && (((m[4]) == 0.0) && (((m[6]) == 0.0) && (((m[8]) == 0.0) && ((m[9]) == 0.0))))))))) { + flags = flags | FlagM44Identity; + } + } + } + return flags; +} + + +/* Primitive. Clip the polygon given in the vertexArray using the temporary vertex array which is assumed to have sufficient size. */ + +EXPORT(sqInt) b3dClipPolygon(void) { + sqInt count; + sqInt outMask; + int *tempVtxArray; + int *vtxArray; + sqInt vtxCount; + + if (!((interpreterProxy->methodArgumentCount()) == 4)) { + return interpreterProxy->primitiveFail(); + } + outMask = interpreterProxy->stackIntegerValue(0); + vtxCount = interpreterProxy->stackIntegerValue(2); + vtxArray = stackPrimitiveVertexArrayofSize(3, vtxCount + 4); + tempVtxArray = stackPrimitiveVertexArrayofSize(1, vtxCount + 4); + if ((vtxArray == null) || ((tempVtxArray == null) || (interpreterProxy->failed()))) { + return interpreterProxy->primitiveFail(); + } + vtxArray -= PrimVertexSize; + tempVtxArray -= PrimVertexSize; + count = clipPolygoncountwithmask(vtxArray, vtxCount, tempVtxArray, outMask); + interpreterProxy->pop(5); + interpreterProxy->pushInteger(count); +} + + +/* Primitive. Compute and return the index for the minimal z value of all objects in the vertex buffer. */ + +EXPORT(sqInt) b3dComputeMinIndexZ(void) { + int *idxArray; + sqInt idxSize; + sqInt minIndex; + sqInt primType; + float *vtxArray; + sqInt vtxSize; + + if (!((interpreterProxy->methodArgumentCount()) == 5)) { + return interpreterProxy->primitiveFail(); + } + idxSize = interpreterProxy->stackIntegerValue(0); + vtxSize = interpreterProxy->stackIntegerValue(2); + primType = interpreterProxy->stackIntegerValue(4); + if (interpreterProxy->failed()) { + return null; + } + vtxArray = stackPrimitiveVertexArrayofSize(3, vtxSize); + idxArray = stackPrimitiveIndexArrayofSizevalidateforVertexSize(1, idxSize, 1, vtxSize); + if ((vtxArray == null) || ((idxArray == null) || (interpreterProxy->failed()))) { + return interpreterProxy->primitiveFail(); + } + if ((primType < 1) || (primType > 6)) { + return interpreterProxy->primitiveFail(); + } + if (primType <= 3) { + minIndex = processNonIndexedIDXofSize(vtxArray, vtxSize); + } else { + minIndex = processIndexedIDXofSizeidxArrayidxSize(vtxArray, vtxSize, idxArray, idxSize); + } + if (!(interpreterProxy->failed())) { + interpreterProxy->pop(6); + interpreterProxy->pushInteger(minIndex); + } +} + + +/* Primitive. Compute and return the minimal z value of all objects in the vertex buffer. */ + +EXPORT(sqInt) b3dComputeMinZ(void) { + int *idxArray; + sqInt idxSize; + double minZ; + sqInt primType; + float *vtxArray; + sqInt vtxSize; + + if (!((interpreterProxy->methodArgumentCount()) == 5)) { + return interpreterProxy->primitiveFail(); + } + idxSize = interpreterProxy->stackIntegerValue(0); + vtxSize = interpreterProxy->stackIntegerValue(2); + primType = interpreterProxy->stackIntegerValue(4); + if (interpreterProxy->failed()) { + return null; + } + vtxArray = stackPrimitiveVertexArrayofSize(3, vtxSize); + idxArray = stackPrimitiveIndexArrayofSizevalidateforVertexSize(1, idxSize, 1, vtxSize); + if ((vtxArray == null) || ((idxArray == null) || (interpreterProxy->failed()))) { + return interpreterProxy->primitiveFail(); + } + if ((primType < 1) || (primType > 6)) { + return interpreterProxy->primitiveFail(); + } + if (primType <= 3) { + minZ = processNonIndexedofSize(vtxArray, vtxSize); + } else { + minZ = processIndexedofSizeidxArrayidxSize(vtxArray, vtxSize, idxArray, idxSize); + } + if (!(interpreterProxy->failed())) { + interpreterProxy->pop(6); + interpreterProxy->pushFloat(minZ); + } +} + + +/* Primitive. Determine the clipping flags for all vertices. */ + +EXPORT(sqInt) b3dDetermineClipFlags(void) { + sqInt result; + void *vtxArray; + sqInt vtxCount; + + if (!((interpreterProxy->methodArgumentCount()) == 2)) { + return interpreterProxy->primitiveFail(); + } + vtxCount = interpreterProxy->stackIntegerValue(0); + if (interpreterProxy->failed()) { + return null; + } + vtxArray = stackPrimitiveVertexArrayofSize(1, vtxCount); + if ((vtxArray == null) || (interpreterProxy->failed())) { + return interpreterProxy->primitiveFail(); + } + result = determineClipFlagscount(vtxArray, vtxCount); + if (!(interpreterProxy->failed())) { + interpreterProxy->pop(3); + interpreterProxy->pushInteger(result); + } +} + +EXPORT(sqInt) b3dInitPrimitiveObject(void) { + int *idxArray; + sqInt idxSize; + void *primObj; + sqInt primOop; + sqInt primSize; + sqInt primitive; + sqInt textureIndex; + int *vtxArray; + sqInt vtxSize; + + if (!((interpreterProxy->methodArgumentCount()) == 8)) { + return interpreterProxy->primitiveFail(); + } + textureIndex = interpreterProxy->stackIntegerValue(0); + if (interpreterProxy->failed()) { + return null; + } + loadViewportFrom(1); + if (interpreterProxy->failed()) { + return null; + } + vtxSize = interpreterProxy->stackIntegerValue(4); + vtxArray = stackPrimitiveVertexArrayofSize(5, vtxSize); + if (vtxArray == null) { + return interpreterProxy->primitiveFail(); + } + idxSize = interpreterProxy->stackIntegerValue(2); + idxArray = stackPrimitiveIndexArrayofSizevalidateforVertexSize(3, idxSize, 1, vtxSize); + if (idxArray == null) { + return interpreterProxy->primitiveFail(); + } + primitive = interpreterProxy->stackIntegerValue(6); + if ((primitive < 1) || (primitive > PrimTypeMax)) { + return interpreterProxy->primitiveFail(); + } + if (!((primitive == 3) || ((primitive == 5) || (primitive == 6)))) { + return interpreterProxy->primitiveFail(); + } + primOop = interpreterProxy->stackObjectValue(7); + if (interpreterProxy->failed()) { + return null; + } + if (!(interpreterProxy->isWords(primOop))) { + return interpreterProxy->primitiveFail(); + } + primObj = interpreterProxy->firstIndexableField(primOop); + + /* Do the work */ + + primSize = interpreterProxy->byteSizeOf(primOop); + if (primitive == 3) { + if (b3dAddPolygonObject((void*) primObj, primSize, B3D_FACE_RGB, textureIndex, (B3DPrimitiveVertex*) vtxArray, vtxSize, &viewport) != B3D_NO_ERROR) { + return interpreterProxy->primitiveFail(); + } + } + if (primitive == 5) { + if (b3dAddIndexedTriangleObject((void*) primObj, primSize, B3D_FACE_RGB, textureIndex, (B3DPrimitiveVertex*) vtxArray, vtxSize, (B3DInputFace*) idxArray, idxSize / 3, &viewport) != B3D_NO_ERROR) { + return interpreterProxy->primitiveFail(); + } + } + if (primitive == 6) { + if (b3dAddIndexedQuadObject((void*) primObj, primSize, B3D_FACE_RGB, textureIndex, (B3DPrimitiveVertex*) vtxArray, vtxSize, (B3DInputQuad*) idxArray, idxSize / 4, &viewport) != B3D_NO_ERROR) { + return interpreterProxy->primitiveFail(); + } + } + interpreterProxy->pop(9); + interpreterProxy->push(primOop); +} + + +/* Primitive. Initialize the primitive level objects of the given rasterizer. */ + +EXPORT(sqInt) b3dInitializeRasterizerState(void) { + void *obj; + sqInt objLen; + sqInt objOop; + sqInt stateOop; + + if (!((interpreterProxy->methodArgumentCount()) == 0)) { + return interpreterProxy->primitiveFail(); + } + stateOop = interpreterProxy->stackObjectValue(0); + if (interpreterProxy->failed()) { + return null; + } + if (!((interpreterProxy->isPointers(stateOop)) && ((interpreterProxy->slotSizeOf(stateOop)) >= 7))) { + return interpreterProxy->primitiveFail(); + } + objOop = interpreterProxy->fetchPointerofObject(0, stateOop); + if (((objOop & 1)) || (!(interpreterProxy->isWords(objOop)))) { + return interpreterProxy->primitiveFail(); + } + objLen = interpreterProxy->byteSizeOf(objOop); + obj = interpreterProxy->firstIndexableField(objOop); + if (b3dInitializeFaceAllocator(obj, objLen) != B3D_NO_ERROR) { + return interpreterProxy->primitiveFail(); + } + objOop = interpreterProxy->fetchPointerofObject(1, stateOop); + if (((objOop & 1)) || (!(interpreterProxy->isWords(objOop)))) { + return interpreterProxy->primitiveFail(); + } + objLen = interpreterProxy->byteSizeOf(objOop); + obj = interpreterProxy->firstIndexableField(objOop); + if (b3dInitializeEdgeAllocator(obj, objLen) != B3D_NO_ERROR) { + return interpreterProxy->primitiveFail(); + } + objOop = interpreterProxy->fetchPointerofObject(2, stateOop); + if (((objOop & 1)) || (!(interpreterProxy->isWords(objOop)))) { + return interpreterProxy->primitiveFail(); + } + objLen = interpreterProxy->byteSizeOf(objOop); + obj = interpreterProxy->firstIndexableField(objOop); + if (b3dInitializeAttrAllocator(obj, objLen) != B3D_NO_ERROR) { + return interpreterProxy->primitiveFail(); + } + objOop = interpreterProxy->fetchPointerofObject(3, stateOop); + if (((objOop & 1)) || (!(interpreterProxy->isWords(objOop)))) { + return interpreterProxy->primitiveFail(); + } + objLen = interpreterProxy->byteSizeOf(objOop); + obj = interpreterProxy->firstIndexableField(objOop); + if (b3dInitializeAET(obj, objLen) != B3D_NO_ERROR) { + return interpreterProxy->primitiveFail(); + } + objOop = interpreterProxy->fetchPointerofObject(4, stateOop); + if (((objOop & 1)) || (!(interpreterProxy->isWords(objOop)))) { + return interpreterProxy->primitiveFail(); + } + objLen = interpreterProxy->byteSizeOf(objOop); + obj = interpreterProxy->firstIndexableField(objOop); + if (b3dInitializeEdgeList(obj, objLen) != B3D_NO_ERROR) { + return interpreterProxy->primitiveFail(); + } + objOop = interpreterProxy->fetchPointerofObject(5, stateOop); + if (((objOop & 1)) || (!(interpreterProxy->isWords(objOop)))) { + return interpreterProxy->primitiveFail(); + } + objLen = interpreterProxy->byteSizeOf(objOop); + obj = interpreterProxy->firstIndexableField(objOop); + if (b3dInitializeFillList(obj, objLen) != B3D_NO_ERROR) { + return interpreterProxy->primitiveFail(); + } +} + + +/* Primitive. Perform an inplace house holder matrix inversion */ + +EXPORT(sqInt) b3dInplaceHouseHolderInvert(void) { + double beta; + double d[4][4]; + sqInt i; + sqInt j; + sqInt k; + double m[4][4]; + sqInt r; + float *rcvr; + double s; + double sigma; + double sum; + double x[4][4] = { {1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1} }; + + ; + rcvr = stackMatrix(0); + for (i = 0; i <= 3; i += 1) { + for (j = 0; j <= 3; j += 1) { + (m[i])[j] = (rcvr[(i * 4) + j]); + } + } + for (j = 0; j <= 3; j += 1) { + sigma = 0.0; + for (i = j; i <= 3; i += 1) { + sigma += ((m[i])[j]) * ((m[i])[j]); + } + if (sigma < 1.0e-10) { + return interpreterProxy->primitiveFail(); + } + if (((m[j])[j]) < 0.0) { + s = sqrt(sigma); + } else { + s = 0.0 - (sqrt(sigma)); + } + for (r = 0; r <= 3; r += 1) { + (d[j])[r] = s; + } + beta = 1.0 / ((s * ((m[j])[j])) - sigma); + (m[j])[j] = (((m[j])[j]) - s); + for (k = (j + 1); k <= 3; k += 1) { + sum = 0.0; + for (i = j; i <= 3; i += 1) { + sum += ((m[i])[j]) * ((m[i])[k]); + } + sum = sum * beta; + for (i = j; i <= 3; i += 1) { + (m[i])[k] = (((m[i])[k]) + (((m[i])[j]) * sum)); + } + } + for (r = 0; r <= 3; r += 1) { + sum = 0.0; + for (i = j; i <= 3; i += 1) { + sum += ((x[i])[r]) * ((m[i])[j]); + } + sum = sum * beta; + for (i = j; i <= 3; i += 1) { + (x[i])[r] = (((x[i])[r]) + (sum * ((m[i])[j]))); + } + } + } + for (r = 0; r <= 3; r += 1) { + for (i = 3; i >= 0; i += -1) { + for (j = (i + 1); j <= 3; j += 1) { + (x[i])[r] = (((x[i])[r]) - (((x[j])[r]) * ((m[i])[j]))); + } + (x[i])[r] = (((x[i])[r]) / ((d[i])[r])); + } + } + for (i = 0; i <= 3; i += 1) { + for (j = 0; j <= 3; j += 1) { + rcvr[(i * 4) + j] = (((float) ((x[i])[j]))); + } + } +} + + +/* Primitive. Load the given index array into the receiver. + NOTE: dstStart is a zero-based index. */ + +EXPORT(sqInt) b3dLoadIndexArray(void) { + sqInt count; + sqInt dstArray; + int *dstPtr; + sqInt dstSize; + sqInt dstStart; + sqInt i; + sqInt idx; + sqInt maxValue; + sqInt srcArray; + int *srcPtr; + sqInt vtxOffset; + + vtxOffset = interpreterProxy->stackIntegerValue(0); + maxValue = interpreterProxy->stackIntegerValue(1); + count = interpreterProxy->stackIntegerValue(2); + srcArray = interpreterProxy->stackObjectValue(3); + dstStart = interpreterProxy->stackIntegerValue(4); + dstArray = interpreterProxy->stackObjectValue(5); + if (interpreterProxy->failed()) { + return null; + } + if (!(interpreterProxy->isWords(srcArray))) { + return interpreterProxy->primitiveFail(); + } + if ((interpreterProxy->slotSizeOf(srcArray)) < count) { + return interpreterProxy->primitiveFail(); + } + + /* Check dstArray */ + + srcPtr = ((int*) (interpreterProxy->firstIndexableField(srcArray))); + + /* Check if there is enough room left in dstArray */ + + dstSize = interpreterProxy->slotSizeOf(dstArray); + if ((dstStart + count) > dstSize) { + return interpreterProxy->primitiveFail(); + } + + /* Do the actual work */ + + dstPtr = ((int *) (interpreterProxy->firstIndexableField(dstArray))); + for (i = 0; i <= (count - 1); i += 1) { + idx = srcPtr[i]; + if ((idx < 1) || (idx > maxValue)) { + return interpreterProxy->primitiveFail(); + } + dstPtr[dstStart + i] = (idx + vtxOffset); + } + interpreterProxy->pop(7); + interpreterProxy->pushInteger(count); +} + + +/* Primitive. Load the data into the given vertex buffer. + NOTE: dstStart is a zero-based index. */ + +EXPORT(sqInt) b3dLoadVertexBuffer(void) { + int *colorPtr; + sqInt count; + int *defaultColor; + int *defaultNormal; + int *defaultTexCoords; + int *defaultVtx; + int *dstPtr; + sqInt dstStart; + sqInt i; + int *normalPtr; + int *pVtx; + int *texPtr; + int *vtxPtr; + + defaultVtx = stackPrimitiveVertex(0); + count = interpreterProxy->stackIntegerValue(1); + texPtr = vbLoadArraysize(interpreterProxy->stackObjectValue(2), 2 * count); + colorPtr = vbLoadArraysize(interpreterProxy->stackObjectValue(3), count); + normalPtr = vbLoadArraysize(interpreterProxy->stackObjectValue(4), 3 * count); + vtxPtr = vbLoadArraysize(interpreterProxy->stackObjectValue(5), 3 * count); + dstStart = interpreterProxy->stackIntegerValue(6); + + /* Check for all problems above */ + + dstPtr = stackPrimitiveVertexArrayofSize(7, dstStart + count); + if ((dstPtr == null) || ((defaultVtx == null) || (interpreterProxy->failed()))) { + return interpreterProxy->primitiveFail(); + } + if (normalPtr == null) { + defaultNormal = defaultVtx + PrimVtxNormal; + } else { + defaultNormal = normalPtr; + } + if (texPtr == null) { + defaultTexCoords = defaultVtx + PrimVtxTexCoords; + } else { + defaultTexCoords = texPtr; + } + if (colorPtr == null) { + defaultColor = defaultVtx + PrimVtxColor32; + } else { + defaultColor = colorPtr; + } + pVtx = dstPtr + (dstStart * PrimVertexSize); + for (i = 0; i <= (count - 1); i += 1) { + pVtx[PrimVtxPositionX] = (vtxPtr[0]); + pVtx[PrimVtxPositionY] = (vtxPtr[1]); + pVtx[PrimVtxPositionZ] = (vtxPtr[2]); + pVtx[PrimVtxNormalX] = (defaultNormal[0]); + pVtx[PrimVtxNormalY] = (defaultNormal[1]); + pVtx[PrimVtxNormalZ] = (defaultNormal[2]); + pVtx[PrimVtxColor32] = (defaultColor[0]); + pVtx[PrimVtxTexCoordU] = (defaultTexCoords[0]); + pVtx[PrimVtxTexCoordV] = (defaultTexCoords[1]); + pVtx += PrimVertexSize; + vtxPtr += 3; + if (!(normalPtr == null)) { + defaultNormal += 3; + } + if (!(colorPtr == null)) { + defaultColor += 1; + } + if (!(texPtr == null)) { + defaultTexCoords += 2; + } + } + interpreterProxy->pop(9); + interpreterProxy->pushInteger(count); +} + + +/* Primitive. Determine the bounds for all vertices in the vertex buffer. */ + +EXPORT(sqInt) b3dMapVertexBuffer(void) { + sqInt boxArray; + void *vtxArray; + sqInt vtxCount; + + if (!((interpreterProxy->methodArgumentCount()) == 3)) { + return interpreterProxy->primitiveFail(); + } + boxArray = interpreterProxy->stackObjectValue(0); + if (interpreterProxy->failed()) { + return null; + } + if (!(((interpreterProxy->fetchClassOf(boxArray)) == (interpreterProxy->classArray())) && ((interpreterProxy->slotSizeOf(boxArray)) == 4))) { + return interpreterProxy->primitiveFail(); + } + vtxCount = interpreterProxy->stackIntegerValue(1); + if (interpreterProxy->failed()) { + return null; + } + vtxArray = stackPrimitiveVertexArrayofSize(2, vtxCount); + if ((vtxArray == null) || (interpreterProxy->failed())) { + return interpreterProxy->primitiveFail(); + } + mapVBofSizeinto(vtxArray, vtxCount, boxArray); + if (!(interpreterProxy->failed())) { + interpreterProxy->pop(3); + } +} + +EXPORT(sqInt) b3dOrthoNormInverseMatrix(void) { + float *dst; + sqInt dstOop; + double rx; + double ry; + double rz; + float *src; + sqInt srcOop; + double x; + double y; + double z; + + if (!((interpreterProxy->methodArgumentCount()) == 0)) { + return interpreterProxy->primitiveFail(); + } + srcOop = interpreterProxy->stackObjectValue(0); + if (interpreterProxy->failed()) { + return null; + } + if (!((interpreterProxy->isWords(srcOop)) && ((interpreterProxy->slotSizeOf(srcOop)) == 16))) { + return interpreterProxy->primitiveFail(); + } + + /* reload srcOop in case of GC */ + + dstOop = interpreterProxy->clone(srcOop); + srcOop = interpreterProxy->stackObjectValue(0); + src = interpreterProxy->firstIndexableField(srcOop); + + /* Transpose upper 3x3 matrix */ + /* dst at: 0 put: (src at: 0). */ + + dst = interpreterProxy->firstIndexableField(dstOop); + dst[1] = (src[4]); + dst[2] = (src[8]); + dst[4] = (src[1]); + dst[6] = (src[9]); + dst[8] = (src[2]); + dst[9] = (src[6]); + x = src[3]; + y = src[7]; + z = src[11]; + rx = ((x * (dst[0])) + (y * (dst[1]))) + (z * (dst[2])); + ry = ((x * (dst[4])) + (y * (dst[5]))) + (z * (dst[6])); + rz = ((x * (dst[8])) + (y * (dst[9]))) + (z * (dst[10])); + dst[3] = (((float) (0.0 - rx))); + dst[7] = (((float) (0.0 - ry))); + dst[11] = (((float) (0.0 - rz))); + interpreterProxy->pop(1); + interpreterProxy->push(dstOop); +} + + +/* Primitive. Return the next clipped triangle from the vertex buffer and return its index. */ + +EXPORT(sqInt) b3dPrimitiveNextClippedTriangle(void) { + sqInt firstIndex; + sqInt i; + sqInt idx1; + sqInt idx2; + sqInt idx3; + int *idxArray; + sqInt idxCount; + sqInt triMask; + int *vtxArray; + sqInt vtxCount; + + if (!((interpreterProxy->methodArgumentCount()) == 5)) { + return interpreterProxy->primitiveFail(); + } + idxCount = interpreterProxy->stackIntegerValue(0); + vtxCount = interpreterProxy->stackIntegerValue(2); + firstIndex = interpreterProxy->stackIntegerValue(4); + if (interpreterProxy->failed()) { + return null; + } + vtxArray = stackPrimitiveVertexArrayofSize(3, vtxCount); + idxArray = stackPrimitiveIndexArrayofSizevalidateforVertexSize(1, idxCount, 1, vtxCount); + if ((vtxArray == null) || ((idxArray == null) || (interpreterProxy->failed()))) { + return interpreterProxy->primitiveFail(); + } + idxArray -= 1; + vtxArray -= PrimVertexSize; + for (i = firstIndex; i <= idxCount; i += 3) { + idx1 = idxArray[i]; + idx2 = idxArray[i + 1]; + idx3 = idxArray[i + 2]; + if (!((idx1 == 0) || ((idx2 == 0) || (idx3 == 0)))) { + + /* Check if tri is completely inside */ + + triMask = (vtxArray[(idx1 * PrimVertexSize) + PrimVtxClipFlags]) & ((vtxArray[(idx2 * PrimVertexSize) + PrimVtxClipFlags]) & (vtxArray[(idx3 * PrimVertexSize) + PrimVtxClipFlags])); + if (!((InAllMask & triMask) == InAllMask)) { + if (triMask & OutAllMask) { + idxArray[i] = 0; + idxArray[i + 1] = 0; + idxArray[i + 2] = 0; + } else { + interpreterProxy->pop(6); + interpreterProxy->pushInteger(i); + return null; + } + } + } + } + interpreterProxy->pop(6); + interpreterProxy->pushInteger(0); +} + + +/* Primitive. Return the minimal number of words needed for a primitive object. */ + +EXPORT(sqInt) b3dPrimitiveObjectSize(void) { + sqInt objSize; + + objSize = (((sqInt) (sizeof(B3DPrimitiveObject) + sizeof(B3DPrimitiveVertex)) >> 2)) + 1; + interpreterProxy->pop(1); + interpreterProxy->pushInteger(objSize); +} + + +/* Primitive. Return the minimal number of words needed for a primitive object. */ + +EXPORT(sqInt) b3dPrimitiveTextureSize(void) { + sqInt objSize; + + objSize = (((sqInt) (sizeof(B3DTexture)) >> 2)) + 1; + interpreterProxy->pop(1); + interpreterProxy->pushInteger(objSize); +} + + +/* Primitive. Return the version of the rasterizer. */ + +EXPORT(sqInt) b3dRasterizerVersion(void) { + interpreterProxy->pop(1); + interpreterProxy->pushInteger(1); +} + + +/* Primitive. Shade all the vertices in the vertex buffer using the given array of primitive light sources. Return true on success. */ + +EXPORT(sqInt) b3dShadeVertexBuffer(void) { + sqInt i; + sqInt j; + sqInt lightArray; + sqInt lightCount; + float *vtxArray; + sqInt vtxCount; + sqInt lightOop; + sqInt rgba; + sqInt a; + sqInt b; + sqInt g; + sqInt r; + + vbFlags = interpreterProxy->stackIntegerValue(0); + primMaterial = stackMaterialValue(1); + lightArray = stackLightArrayValue(2); + vtxCount = interpreterProxy->stackIntegerValue(3); + vtxArray = stackPrimitiveVertexArrayofSize(4, vtxCount); + if ((vtxArray == null) || ((primMaterial == null) || (interpreterProxy->failed()))) { + return interpreterProxy->primitiveFail(); + } + litVertex = vtxArray; + + /* Go over all vertices */ + + lightCount = interpreterProxy->slotSizeOf(lightArray); + for (i = 1; i <= vtxCount; i += 1) { + /* begin loadPrimitiveVertex */ + rgba = (((int*) litVertex))[PrimVtxColor32]; + vtxInColor[2] = ((rgba & 255) * (1.0 / 255.0)); + rgba = ((usqInt) rgba) >> 8; + vtxInColor[1] = ((rgba & 255) * (1.0 / 255.0)); + rgba = ((usqInt) rgba) >> 8; + vtxInColor[0] = ((rgba & 255) * (1.0 / 255.0)); + rgba = ((usqInt) rgba) >> 8; + vtxInColor[3] = ((rgba & 255) * (1.0 / 255.0)); + if (vbFlags & VBTrackEmission) { + vtxOutColor[0] = ((vtxInColor[0]) + (primMaterial[EmissionRed])); + vtxOutColor[1] = ((vtxInColor[1]) + (primMaterial[EmissionGreen])); + vtxOutColor[2] = ((vtxInColor[2]) + (primMaterial[EmissionBlue])); + vtxOutColor[3] = ((vtxInColor[3]) + (primMaterial[EmissionAlpha])); + } else { + vtxOutColor[0] = (primMaterial[EmissionRed]); + vtxOutColor[1] = (primMaterial[EmissionGreen]); + vtxOutColor[2] = (primMaterial[EmissionBlue]); + vtxOutColor[3] = (primMaterial[EmissionAlpha]); + } + for (j = 0; j <= (lightCount - 1); j += 1) { + /* begin fetchLightSource:ofObject: */ + lightOop = interpreterProxy->fetchPointerofObject(j, lightArray); + primLight = interpreterProxy->firstIndexableField(lightOop); + /* begin loadPrimitiveLightSource */ + lightFlags = (((int*) primLight))[PrimLightFlags]; + shadeVertex(); + } + /* begin storePrimitiveVertex */ + r = ((sqInt)((vtxOutColor[0]) * 255)); + r = (((((r < 255) ? r : 255)) < 0) ? 0 : (((r < 255) ? r : 255))); + g = ((sqInt)((vtxOutColor[1]) * 255)); + g = (((((g < 255) ? g : 255)) < 0) ? 0 : (((g < 255) ? g : 255))); + b = ((sqInt)((vtxOutColor[2]) * 255)); + b = (((((b < 255) ? b : 255)) < 0) ? 0 : (((b < 255) ? b : 255))); + a = ((sqInt)((vtxOutColor[3]) * 255)); + a = (((((a < 255) ? a : 255)) < 0) ? 0 : (((a < 255) ? a : 255))); + (((int*) litVertex))[PrimVtxColor32] = (b + ((g + ((r + (a << 8)) << 8)) << 8)); + litVertex += PrimVertexSize; + } + interpreterProxy->pop(6); + interpreterProxy->pushBool(1); +} + + +/* Return the current shader version. */ + +EXPORT(sqInt) b3dShaderVersion(void) { + interpreterProxy->pop(1); + interpreterProxy->pushInteger(1); +} + + +/* Primitive. Start the rasterizer. */ + +EXPORT(sqInt) b3dStartRasterizer(void) { + sqInt errCode; + + if (!((interpreterProxy->methodArgumentCount()) == 3)) { + return interpreterProxy->primitiveFail(); + } + if (!(loadRasterizerState(2))) { + return interpreterProxy->primitiveFail(); + } + loadTexturesFrom(0); + if (interpreterProxy->failed()) { + return null; + } + loadObjectsFrom(1); + if (interpreterProxy->failed()) { + return null; + } + errCode = b3dMainLoop(&state, B3D_NO_ERROR); + storeObjectsInto(1); + interpreterProxy->pop(4); + interpreterProxy->pushInteger(errCode); +} + +EXPORT(sqInt) b3dTransformDirection(void) { + float *matrix; + double rx; + double ry; + double rz; + sqInt v3Oop; + float *vertex; + double x; + double y; + double z; + + if (!((interpreterProxy->methodArgumentCount()) == 1)) { + return interpreterProxy->primitiveFail(); + } + v3Oop = interpreterProxy->stackObjectValue(0); + if (interpreterProxy->failed()) { + return null; + } + if (!((interpreterProxy->isWords(v3Oop)) && ((interpreterProxy->slotSizeOf(v3Oop)) == 3))) { + return interpreterProxy->primitiveFail(); + } + vertex = interpreterProxy->firstIndexableField(v3Oop); + matrix = stackMatrix(1); + if (matrix == null) { + return interpreterProxy->primitiveFail(); + } + x = vertex[0]; + y = vertex[1]; + z = vertex[2]; + rx = ((x * (matrix[0])) + (y * (matrix[1]))) + (z * (matrix[2])); + ry = ((x * (matrix[4])) + (y * (matrix[5]))) + (z * (matrix[6])); + rz = ((x * (matrix[8])) + (y * (matrix[9]))) + (z * (matrix[10])); + v3Oop = interpreterProxy->clone(v3Oop); + vertex = interpreterProxy->firstIndexableField(v3Oop); + vertex[0] = (((float) rx)); + vertex[1] = (((float) ry)); + vertex[2] = (((float) rz)); + interpreterProxy->pop(2); + interpreterProxy->push(v3Oop); +} + + +/* Transform two matrices into the third */ + +EXPORT(sqInt) b3dTransformMatrixWithInto(void) { + float *m1; + float *m2; + float *m3; + + m3 = stackMatrix(0); + m2 = stackMatrix(1); + m1 = stackMatrix(2); + if (((m1 == null) || (m2 == null)) || (m3 == null)) { + return interpreterProxy->primitiveFail(); + } + if (m2 == m3) { + return interpreterProxy->primitiveFail(); + } + transformMatrixwithinto(m1, m2, m3); + interpreterProxy->pop(3); +} + +EXPORT(sqInt) b3dTransformPoint(void) { + float *matrix; + double rw; + double rx; + double ry; + double rz; + sqInt v3Oop; + float *vertex; + double x; + double y; + double z; + + if (!((interpreterProxy->methodArgumentCount()) == 1)) { + return interpreterProxy->primitiveFail(); + } + v3Oop = interpreterProxy->stackObjectValue(0); + if (interpreterProxy->failed()) { + return null; + } + if (!((interpreterProxy->isWords(v3Oop)) && ((interpreterProxy->slotSizeOf(v3Oop)) == 3))) { + return interpreterProxy->primitiveFail(); + } + vertex = interpreterProxy->firstIndexableField(v3Oop); + matrix = stackMatrix(1); + if (matrix == null) { + return interpreterProxy->primitiveFail(); + } + x = vertex[0]; + y = vertex[1]; + z = vertex[2]; + rx = (((x * (matrix[0])) + (y * (matrix[1]))) + (z * (matrix[2]))) + (matrix[3]); + ry = (((x * (matrix[4])) + (y * (matrix[5]))) + (z * (matrix[6]))) + (matrix[7]); + rz = (((x * (matrix[8])) + (y * (matrix[9]))) + (z * (matrix[10]))) + (matrix[11]); + rw = (((x * (matrix[12])) + (y * (matrix[13]))) + (z * (matrix[14]))) + (matrix[15]); + v3Oop = interpreterProxy->clone(v3Oop); + vertex = interpreterProxy->firstIndexableField(v3Oop); + if (rw == 1.0) { + vertex[0] = (((float) rx)); + vertex[1] = (((float) ry)); + vertex[2] = (((float) rz)); + } else { + if (rw == 0.0) { + rw = 0.0; + } else { + rw = 1.0 / rw; + } + vertex[0] = (((float) (rx * rw))); + vertex[1] = (((float) (ry * rw))); + vertex[2] = (((float) (rz * rw))); + } + interpreterProxy->pop(2); + interpreterProxy->push(v3Oop); +} + + +/* Transform the normal of the given primitive vertex using the argument matrix and rescale the normal if necessary. */ + +EXPORT(sqInt) b3dTransformPrimitiveNormal(void) { + float *matrix; + float *pVertex; + sqInt rescale; + + rescale = interpreterProxy->stackValue(0); + if (!(rescale == (interpreterProxy->nilObject()))) { + rescale = interpreterProxy->booleanValueOf(rescale); + } + matrix = stackMatrix(1); + pVertex = stackPrimitiveVertex(2); + if ((matrix == null) || (pVertex == null)) { + return interpreterProxy->primitiveFail(); + } + if ((rescale != 1) && (rescale != 0)) { + rescale = analyzeMatrix3x3Length(matrix); + } + transformPrimitiveNormalbyrescale(pVertex, matrix, rescale); + interpreterProxy->pop(3); +} + + +/* Transform the position of the given primitive vertex the given matrix + and store the result back inplace. */ + +EXPORT(sqInt) b3dTransformPrimitivePosition(void) { + float *matrix; + float *pVertex; + + matrix = stackMatrix(0); + pVertex = stackPrimitiveVertex(1); + if ((matrix == null) || (pVertex == null)) { + return interpreterProxy->primitiveFail(); + } + transformPrimitivePositionby(pVertex, matrix); + interpreterProxy->pop(2); +} + + +/* Transform the position of the given primitive vertex the given matrix + and store the result in homogenous coordinates at rasterPos. */ + +EXPORT(sqInt) b3dTransformPrimitiveRasterPosition(void) { + float *matrix; + float *pVertex; + + matrix = stackMatrix(0); + pVertex = stackPrimitiveVertex(1); + if ((matrix == null) || (pVertex == null)) { + return interpreterProxy->primitiveFail(); + } + transformPrimitiveRasterPositionby(pVertex, matrix); + interpreterProxy->pop(2); +} + + +/* Transform an entire vertex buffer using the supplied modelview and projection matrix. */ + +EXPORT(sqInt) b3dTransformVertexBuffer(void) { + sqInt flags; + float *modelViewMatrix; + float *projectionMatrix; + float *vtxArray; + sqInt vtxCount; + + flags = interpreterProxy->stackIntegerValue(0); + projectionMatrix = stackMatrix(1); + modelViewMatrix = stackMatrix(2); + vtxCount = interpreterProxy->stackIntegerValue(3); + vtxArray = stackPrimitiveVertexArrayofSize(4, vtxCount); + if (((projectionMatrix == null) || (modelViewMatrix == null)) || (vtxArray == null)) { + return interpreterProxy->primitiveFail(); + } + if (interpreterProxy->failed()) { + return null; + } + transformVBcountbyandflags(vtxArray, vtxCount, modelViewMatrix, projectionMatrix, flags); + interpreterProxy->pop(5); +} + + +/* Return the current version of the transformer */ + +EXPORT(sqInt) b3dTransformerVersion(void) { + interpreterProxy->pop(1); + interpreterProxy->pushInteger(1); +} + +EXPORT(sqInt) b3dTransposeMatrix(void) { + float *dst; + sqInt dstOop; + float *src; + sqInt srcOop; + + if (!((interpreterProxy->methodArgumentCount()) == 0)) { + return interpreterProxy->primitiveFail(); + } + srcOop = interpreterProxy->stackObjectValue(0); + if (interpreterProxy->failed()) { + return null; + } + if (!((interpreterProxy->isWords(srcOop)) && ((interpreterProxy->slotSizeOf(srcOop)) == 16))) { + return interpreterProxy->primitiveFail(); + } + + /* reload srcOop in case of GC */ + + dstOop = interpreterProxy->clone(srcOop); + srcOop = interpreterProxy->stackObjectValue(0); + src = interpreterProxy->firstIndexableField(srcOop); + + /* dst at: 0 put: (src at: 0). */ + + dst = interpreterProxy->firstIndexableField(dstOop); + dst[1] = (src[4]); + dst[2] = (src[8]); + dst[3] = (src[12]); + dst[4] = (src[1]); + dst[6] = (src[9]); + dst[7] = (src[13]); + dst[8] = (src[2]); + dst[9] = (src[6]); + dst[11] = (src[14]); + dst[12] = (src[3]); + dst[13] = (src[7]); + dst[14] = (src[11]); + interpreterProxy->pop(1); + interpreterProxy->push(dstOop); +} + +static double backClipValueFromto(sqInt last, sqInt next) { + return (((((float *) last))[PrimVtxRasterPosZ]) - ((((float *) last))[PrimVtxRasterPosW])) / ((((((float *) next))[PrimVtxRasterPosW]) - ((((float *) last))[PrimVtxRasterPosW])) - (((((float *) next))[PrimVtxRasterPosZ]) - ((((float *) last))[PrimVtxRasterPosZ]))); +} + +static double bottomClipValueFromto(sqInt last, sqInt next) { + return (0.0 - (((((float *) last))[PrimVtxRasterPosY]) + ((((float *) last))[PrimVtxRasterPosW]))) / ((((((float *) next))[PrimVtxRasterPosW]) - ((((float *) last))[PrimVtxRasterPosW])) + (((((float *) next))[PrimVtxRasterPosY]) - ((((float *) last))[PrimVtxRasterPosY]))); +} + +static sqInt clipPolygoncountwithmask(int *vtxArray, sqInt vtxCount, int *tempVtxArray, sqInt outMask) { + sqInt count; + + if (outMask == OutLeftBit) { + return clipPolygonLeftFromtocount(tempVtxArray, vtxArray, vtxCount); + } + if (outMask == OutRightBit) { + return clipPolygonRightFromtocount(tempVtxArray, vtxArray, vtxCount); + } + if (outMask == OutTopBit) { + return clipPolygonTopFromtocount(tempVtxArray, vtxArray, vtxCount); + } + if (outMask == OutBottomBit) { + return clipPolygonBottomFromtocount(tempVtxArray, vtxArray, vtxCount); + } + if (outMask == OutFrontBit) { + return clipPolygonFrontFromtocount(tempVtxArray, vtxArray, vtxCount); + } + if (outMask == OutBackBit) { + return clipPolygonBackFromtocount(tempVtxArray, vtxArray, vtxCount); + } + count = vtxCount; + count = clipPolygonLeftFromtocount(vtxArray, tempVtxArray, count); + if (count == 0) { + return 0; + } + count = clipPolygonRightFromtocount(tempVtxArray, vtxArray, count); + if (count == 0) { + return 0; + } + count = clipPolygonTopFromtocount(vtxArray, tempVtxArray, count); + if (count == 0) { + return 0; + } + count = clipPolygonBottomFromtocount(tempVtxArray, vtxArray, count); + if (count == 0) { + return 0; + } + count = clipPolygonFrontFromtocount(vtxArray, tempVtxArray, count); + if (count == 0) { + return 0; + } + count = clipPolygonBackFromtocount(tempVtxArray, vtxArray, count); + return count; +} + +static sqInt clipPolygonBackFromtocount(int *buf1, int *buf2, sqInt n) { + sqInt i; + sqInt inLast; + sqInt inNext; + sqInt j; + int *last; + int *next; + sqInt outIndex; + double t; + + outIndex = 0; + last = buf1 + (n * PrimVertexSize); + next = buf1 + PrimVertexSize; + inLast = (last[PrimVtxClipFlags]) & InBackBit; + for (i = 1; i <= n; i += 1) { + inNext = (next[PrimVtxClipFlags]) & InBackBit; + if (!(inLast == inNext)) { + + /* Passes clip boundary */ + + t = (((((float *) last))[PrimVtxRasterPosZ]) - ((((float *) last))[PrimVtxRasterPosW])) / ((((((float *) next))[PrimVtxRasterPosW]) - ((((float *) last))[PrimVtxRasterPosW])) - (((((float *) next))[PrimVtxRasterPosZ]) - ((((float *) last))[PrimVtxRasterPosZ]))); + outIndex += 1; + interpolateFromtoatinto(((float *) last), ((float *) next), t, ((float*) (buf2 + (outIndex * PrimVertexSize)))); + } + if (inNext) { + outIndex += 1; + for (j = 0; j <= (PrimVertexSize - 1); j += 1) { + buf2[(outIndex * PrimVertexSize) + j] = (next[j]); + } + } + last = next; + inLast = inNext; + next += PrimVertexSize; + } + return outIndex; +} + +static sqInt clipPolygonBottomFromtocount(int *buf1, int *buf2, sqInt n) { + sqInt i; + sqInt inLast; + sqInt inNext; + sqInt j; + int *last; + int *next; + sqInt outIndex; + double t; + + outIndex = 0; + last = buf1 + (n * PrimVertexSize); + next = buf1 + PrimVertexSize; + inLast = (last[PrimVtxClipFlags]) & InBottomBit; + for (i = 1; i <= n; i += 1) { + inNext = (next[PrimVtxClipFlags]) & InBottomBit; + if (!(inLast == inNext)) { + + /* Passes clip boundary */ + + t = (0.0 - (((((float *) last))[PrimVtxRasterPosY]) + ((((float *) last))[PrimVtxRasterPosW]))) / ((((((float *) next))[PrimVtxRasterPosW]) - ((((float *) last))[PrimVtxRasterPosW])) + (((((float *) next))[PrimVtxRasterPosY]) - ((((float *) last))[PrimVtxRasterPosY]))); + outIndex += 1; + interpolateFromtoatinto(((float *) last), ((float *) next), t, ((float*) (buf2 + (outIndex * PrimVertexSize)))); + } + if (inNext) { + outIndex += 1; + for (j = 0; j <= (PrimVertexSize - 1); j += 1) { + buf2[(outIndex * PrimVertexSize) + j] = (next[j]); + } + } + last = next; + inLast = inNext; + next += PrimVertexSize; + } + return outIndex; +} + +static sqInt clipPolygonFrontFromtocount(int *buf1, int *buf2, sqInt n) { + sqInt i; + sqInt inLast; + sqInt inNext; + sqInt j; + int *last; + int *next; + sqInt outIndex; + double t; + + outIndex = 0; + last = buf1 + (n * PrimVertexSize); + next = buf1 + PrimVertexSize; + inLast = (last[PrimVtxClipFlags]) & InFrontBit; + for (i = 1; i <= n; i += 1) { + inNext = (next[PrimVtxClipFlags]) & InFrontBit; + if (!(inLast == inNext)) { + + /* Passes clip boundary */ + + t = (0.0 - (((((float *) last))[PrimVtxRasterPosZ]) + ((((float *) last))[PrimVtxRasterPosW]))) / ((((((float *) next))[PrimVtxRasterPosW]) - ((((float *) last))[PrimVtxRasterPosW])) + (((((float *) next))[PrimVtxRasterPosZ]) - ((((float *) last))[PrimVtxRasterPosZ]))); + outIndex += 1; + interpolateFromtoatinto(((float *) last), ((float *) next), t, ((float*) (buf2 + (outIndex * PrimVertexSize)))); + } + if (inNext) { + outIndex += 1; + for (j = 0; j <= (PrimVertexSize - 1); j += 1) { + buf2[(outIndex * PrimVertexSize) + j] = (next[j]); + } + } + last = next; + inLast = inNext; + next += PrimVertexSize; + } + return outIndex; +} + +static sqInt clipPolygonLeftFromtocount(int *buf1, int *buf2, sqInt n) { + sqInt i; + sqInt inLast; + sqInt inNext; + sqInt j; + int *last; + int *next; + sqInt outIndex; + double t; + + outIndex = 0; + last = buf1 + (n * PrimVertexSize); + next = buf1 + PrimVertexSize; + inLast = (last[PrimVtxClipFlags]) & InLeftBit; + for (i = 1; i <= n; i += 1) { + inNext = (next[PrimVtxClipFlags]) & InLeftBit; + if (!(inLast == inNext)) { + + /* Passes clip boundary */ + + t = (0.0 - (((((float *) last))[PrimVtxRasterPosX]) + ((((float *) last))[PrimVtxRasterPosW]))) / ((((((float *) next))[PrimVtxRasterPosW]) - ((((float *) last))[PrimVtxRasterPosW])) + (((((float *) next))[PrimVtxRasterPosX]) - ((((float *) last))[PrimVtxRasterPosX]))); + outIndex += 1; + interpolateFromtoatinto(((float *) last), ((float *) next), t, ((float*) (buf2 + (outIndex * PrimVertexSize)))); + } + if (inNext) { + outIndex += 1; + for (j = 0; j <= (PrimVertexSize - 1); j += 1) { + buf2[(outIndex * PrimVertexSize) + j] = (next[j]); + } + } + last = next; + inLast = inNext; + next += PrimVertexSize; + } + return outIndex; +} + +static sqInt clipPolygonRightFromtocount(int *buf1, int *buf2, sqInt n) { + sqInt i; + sqInt inLast; + sqInt inNext; + sqInt j; + int *last; + int *next; + sqInt outIndex; + double t; + + outIndex = 0; + last = buf1 + (n * PrimVertexSize); + next = buf1 + PrimVertexSize; + inLast = (last[PrimVtxClipFlags]) & InRightBit; + for (i = 1; i <= n; i += 1) { + inNext = (next[PrimVtxClipFlags]) & InRightBit; + if (!(inLast == inNext)) { + + /* Passes clip boundary */ + + t = (((((float *) last))[PrimVtxRasterPosX]) - ((((float *) last))[PrimVtxRasterPosW])) / ((((((float *) next))[PrimVtxRasterPosW]) - ((((float *) last))[PrimVtxRasterPosW])) - (((((float *) next))[PrimVtxRasterPosX]) - ((((float *) last))[PrimVtxRasterPosX]))); + outIndex += 1; + interpolateFromtoatinto(((float *) last), ((float *) next), t, ((float*) (buf2 + (outIndex * PrimVertexSize)))); + } + if (inNext) { + outIndex += 1; + for (j = 0; j <= (PrimVertexSize - 1); j += 1) { + buf2[(outIndex * PrimVertexSize) + j] = (next[j]); + } + } + last = next; + inLast = inNext; + next += PrimVertexSize; + } + return outIndex; +} + +static sqInt clipPolygonTopFromtocount(int *buf1, int *buf2, sqInt n) { + sqInt i; + sqInt inLast; + sqInt inNext; + sqInt j; + int *last; + int *next; + sqInt outIndex; + double t; + + outIndex = 0; + last = buf1 + (n * PrimVertexSize); + next = buf1 + PrimVertexSize; + inLast = (last[PrimVtxClipFlags]) & InTopBit; + for (i = 1; i <= n; i += 1) { + inNext = (next[PrimVtxClipFlags]) & InTopBit; + if (!(inLast == inNext)) { + + /* Passes clip boundary */ + + t = (((((float *) last))[PrimVtxRasterPosY]) - ((((float *) last))[PrimVtxRasterPosW])) / ((((((float *) next))[PrimVtxRasterPosW]) - ((((float *) last))[PrimVtxRasterPosW])) - (((((float *) next))[PrimVtxRasterPosY]) - ((((float *) last))[PrimVtxRasterPosY]))); + outIndex += 1; + interpolateFromtoatinto(((float *) last), ((float *) next), t, ((float*) (buf2 + (outIndex * PrimVertexSize)))); + } + if (inNext) { + outIndex += 1; + for (j = 0; j <= (PrimVertexSize - 1); j += 1) { + buf2[(outIndex * PrimVertexSize) + j] = (next[j]); + } + } + last = next; + inLast = inNext; + next += PrimVertexSize; + } + return outIndex; +} + + +/* Compute the attenuation for the current light and vertex */ + +static sqInt computeAttenuation(void) { + lightScale = 1.0; + if (lightFlags & FlagAttenuated) { + lightScale = 1.0 / ((primLight[PrimLightAttenuationConstant]) + (l2vDistance * ((primLight[PrimLightAttenuationLinear]) + (l2vDistance * (primLight[PrimLightAttenuationSquared]))))); + } +} + + +/* Compute the direction for the current light and vertex */ + +static sqInt computeDirection(void) { + double scale; + + if (lightFlags & FlagPositional) { + l2vDirection[0] = ((litVertex[PrimVtxPositionX]) - (primLight[PrimLightPositionX])); + l2vDirection[1] = ((litVertex[PrimVtxPositionY]) - (primLight[PrimLightPositionY])); + l2vDirection[2] = ((litVertex[PrimVtxPositionZ]) - (primLight[PrimLightPositionZ])); + l2vDistance = (((l2vDirection[0]) * (l2vDirection[0])) + ((l2vDirection[1]) * (l2vDirection[1]))) + ((l2vDirection[2]) * (l2vDirection[2])); + if (!((l2vDistance == 0.0) || (l2vDistance == 1.0))) { + l2vDistance = sqrt(l2vDistance); + scale = -1.0 / l2vDistance; + } + l2vDirection[0] = ((l2vDirection[0]) * scale); + l2vDirection[1] = ((l2vDirection[1]) * scale); + l2vDirection[2] = ((l2vDirection[2]) * scale); + } else { + if (lightFlags & FlagDirectional) { + l2vDirection[0] = (primLight[PrimLightDirectionX]); + l2vDirection[1] = (primLight[PrimLightDirectionY]); + l2vDirection[2] = (primLight[PrimLightDirectionZ]); + } + } +} + + +/* Computes + l2vSpecDir _ l2vSpecDir - vtx position safelyNormalized. + */ + +static sqInt computeSpecularDirection(void) { + double scale; + + scale = inverseLengthOfFloat(litVertex + PrimVtxPosition); + l2vSpecDir[0] = ((l2vSpecDir[0]) - ((litVertex[PrimVtxPositionX]) * scale)); + l2vSpecDir[1] = ((l2vSpecDir[1]) - ((litVertex[PrimVtxPositionY]) * scale)); + l2vSpecDir[2] = ((l2vSpecDir[2]) - ((litVertex[PrimVtxPositionZ]) * scale)); +} + + +/* Compute the spot factor for a spot light */ + +static double computeSpotFactor(void) { + double cosAngle; + double deltaCos; + double minCos; + + cosAngle = dotProductOfFloatwithDouble(primLight + PrimLightDirection, l2vDirection); + cosAngle = 0.0 - cosAngle; + minCos = primLight[SpotLightMinCos]; + if (cosAngle < minCos) { + return 0.0; + } + deltaCos = primLight[SpotLightDeltaCos]; + if (deltaCos <= 1.0e-5) { + return 1.0; + } + cosAngle = (cosAngle - minCos) / deltaCos; + return pow(cosAngle,(primLight[SpotLightExponent])); +} + +static sqInt determineClipFlagscount(void *vtxArray, sqInt count) { + sqInt flags; + sqInt fullMask; + sqInt i; + float *vtxPtr; + double w; + double w2; + double x; + double y; + double z; + + vtxPtr = ((float *) vtxArray); + fullMask = InAllMask + OutAllMask; + for (i = 1; i <= count; i += 1) { + w = vtxPtr[PrimVtxRasterPosW]; + w2 = 0.0 - w; + flags = 0; + x = vtxPtr[PrimVtxRasterPosX]; + if (x >= w2) { + flags = flags | InLeftBit; + } else { + flags = flags | OutLeftBit; + } + if (x <= w) { + flags = flags | InRightBit; + } else { + flags = flags | OutRightBit; + } + y = vtxPtr[PrimVtxRasterPosY]; + if (y >= w2) { + flags = flags | InBottomBit; + } else { + flags = flags | OutBottomBit; + } + if (y <= w) { + flags = flags | InTopBit; + } else { + flags = flags | OutTopBit; + } + z = vtxPtr[PrimVtxRasterPosZ]; + if (z >= w2) { + flags = flags | InFrontBit; + } else { + flags = flags | OutFrontBit; + } + if (z <= w) { + flags = flags | InBackBit; + } else { + flags = flags | OutBackBit; + } + fullMask = fullMask & flags; + (((int *) vtxPtr))[PrimVtxClipFlags] = flags; + vtxPtr += PrimVertexSize; + } + return fullMask; +} + +static double dotProductOfFloatwithDouble(float * v1, double *v2) { + return (((v1[0]) * (v2[0])) + ((v1[1]) * (v2[1]))) + ((v1[2]) * (v2[2])); +} + + +/* Fetch the primitive light source from the given array. + Note: No checks are done within here - that happened in stackLightArrayValue: */ + +static void* fetchLightSourceofObject(sqInt index, sqInt anArray) { + sqInt lightOop; + + lightOop = interpreterProxy->fetchPointerofObject(index, anArray); + return interpreterProxy->firstIndexableField(lightOop); +} + +static double frontClipValueFromto(sqInt last, sqInt next) { + return (0.0 - (((((float *) last))[PrimVtxRasterPosZ]) + ((((float *) last))[PrimVtxRasterPosW]))) / ((((((float *) next))[PrimVtxRasterPosW]) - ((((float *) last))[PrimVtxRasterPosW])) + (((((float *) next))[PrimVtxRasterPosZ]) - ((((float *) last))[PrimVtxRasterPosZ]))); +} + + +/* Note: This is coded so that plugins can be run from Squeak. */ + +static VirtualMachine * getInterpreter(void) { + return interpreterProxy; +} + + +/* Note: This is hardcoded so it can be run from Squeak. + The module name is used for validating a module *after* + it is loaded to check if it does really contain the module + we're thinking it contains. This is important! */ + +EXPORT(const char*) getModuleName(void) { + return moduleName; +} + +static sqInt halt(void) { + ; +} + +EXPORT(sqInt) initialiseModule(void) { + loadBBFn = interpreterProxy->ioLoadFunctionFrom("loadBitBltFrom", bbPluginName); + copyBitsFn = interpreterProxy->ioLoadFunctionFrom("copyBitsFromtoat", bbPluginName); + return (loadBBFn != 0) && (copyBitsFn != 0); +} + + +/* Interpolate the primitive vertices last/next at the parameter t */ + +static sqInt interpolateFromtoatinto(float *last, float *next, double t, float *out) { + double delta; + sqInt flags; + unsigned int lastValue; + unsigned int newValue; + unsigned int nextValue; + unsigned int rgbaLast; + unsigned int rgbaNext; + double w; + double w2; + double x; + double y; + double z; + + delta = (next[PrimVtxRasterPosX]) - (last[PrimVtxRasterPosX]); + x = (last[PrimVtxRasterPosX]) + (delta * t); + out[PrimVtxRasterPosX] = (((float) x)); + delta = (next[PrimVtxRasterPosY]) - (last[PrimVtxRasterPosY]); + y = (last[PrimVtxRasterPosY]) + (delta * t); + out[PrimVtxRasterPosY] = (((float) y)); + delta = (next[PrimVtxRasterPosZ]) - (last[PrimVtxRasterPosZ]); + z = (last[PrimVtxRasterPosZ]) + (delta * t); + out[PrimVtxRasterPosZ] = (((float) z)); + delta = (next[PrimVtxRasterPosW]) - (last[PrimVtxRasterPosW]); + w = (last[PrimVtxRasterPosW]) + (delta * t); + out[PrimVtxRasterPosW] = (((float) w)); + w2 = 0.0 - w; + flags = 0; + if (x >= w2) { + flags = flags | InLeftBit; + } else { + flags = flags | OutLeftBit; + } + if (x <= w) { + flags = flags | InRightBit; + } else { + flags = flags | OutRightBit; + } + if (y >= w2) { + flags = flags | InBottomBit; + } else { + flags = flags | OutBottomBit; + } + if (y <= w) { + flags = flags | InTopBit; + } else { + flags = flags | OutTopBit; + } + if (z >= w2) { + flags = flags | InFrontBit; + } else { + flags = flags | OutFrontBit; + } + if (z <= w) { + flags = flags | InBackBit; + } else { + flags = flags | OutBackBit; + } + (((int *) out))[PrimVtxClipFlags] = flags; + rgbaLast = (((unsigned int *) last))[PrimVtxColor32]; + lastValue = rgbaLast & 255; + rgbaLast = ((usqInt) rgbaLast) >> 8; + rgbaNext = (((unsigned int *) next))[PrimVtxColor32]; + nextValue = rgbaNext & 255; + rgbaNext = ((usqInt) rgbaNext) >> 8; + delta = (((int) (nextValue - lastValue))) * t; + newValue = ((sqInt)(lastValue + delta)); + lastValue = rgbaLast & 255; + rgbaLast = ((usqInt) rgbaLast) >> 8; + nextValue = rgbaNext & 255; + rgbaNext = ((usqInt) rgbaNext) >> 8; + delta = (((int) (nextValue - lastValue))) * t; + newValue += (((sqInt)(lastValue + delta))) << 8; + lastValue = rgbaLast & 255; + rgbaLast = ((usqInt) rgbaLast) >> 8; + nextValue = rgbaNext & 255; + rgbaNext = ((usqInt) rgbaNext) >> 8; + delta = (((int) (nextValue - lastValue))) * t; + newValue += (((sqInt)(lastValue + delta))) << 16; + lastValue = rgbaLast & 255; + nextValue = rgbaNext & 255; + delta = (((int) (nextValue - lastValue))) * t; + newValue += (((sqInt)(lastValue + delta))) << 24; + (((unsigned int*) out))[PrimVtxColor32] = newValue; + delta = (next[PrimVtxTexCoordU]) - (last[PrimVtxTexCoordU]); + out[PrimVtxTexCoordU] = (((float) ((last[PrimVtxTexCoordU]) + (delta * t)))); + delta = (next[PrimVtxTexCoordV]) - (last[PrimVtxTexCoordV]); + out[PrimVtxTexCoordV] = (((float) ((last[PrimVtxTexCoordV]) + (delta * t)))); +} + +static double inverseLengthOfDouble(double * aVector) { + double scale; + + scale = (((aVector[0]) * (aVector[0])) + ((aVector[1]) * (aVector[1]))) + ((aVector[2]) * (aVector[2])); + if ((scale == 0.0) || (scale == 1.0)) { + return scale; + } + return 1.0 / (sqrt(scale)); +} + +static double inverseLengthOfFloat(float * aVector) { + double scale; + + scale = (((aVector[0]) * (aVector[0])) + ((aVector[1]) * (aVector[1]))) + ((aVector[2]) * (aVector[2])); + if ((scale == 0.0) || (scale == 1.0)) { + return scale; + } + return 1.0 / (sqrt(scale)); +} + +static double leftClipValueFromto(sqInt last, sqInt next) { + return (0.0 - (((((float *) last))[PrimVtxRasterPosX]) + ((((float *) last))[PrimVtxRasterPosW]))) / ((((((float *) next))[PrimVtxRasterPosW]) - ((((float *) last))[PrimVtxRasterPosW])) + (((((float *) next))[PrimVtxRasterPosX]) - ((((float *) last))[PrimVtxRasterPosX]))); +} + +static sqInt loadObjectsFrom(sqInt stackIndex) { + sqInt arrayOop; + sqInt arraySize; + sqInt i; + B3DPrimitiveObject **objArray; + sqInt objOop; + B3DPrimitiveObject *objPtr; + + arrayOop = interpreterProxy->stackObjectValue(stackIndex); + if (interpreterProxy->failed()) { + return null; + } + if (!((interpreterProxy->fetchClassOf(arrayOop)) == (interpreterProxy->classArray()))) { + return interpreterProxy->primitiveFail(); + } + arraySize = interpreterProxy->slotSizeOf(arrayOop); + if (arraySize > (state.nObjects)) { + return interpreterProxy->primitiveFail(); + } + objArray = state.objects; + for (i = 0; i <= (arraySize - 1); i += 1) { + objOop = interpreterProxy->fetchPointerofObject(i, arrayOop); + if (((objOop & 1)) || (!(interpreterProxy->isWords(objOop)))) { + return interpreterProxy->primitiveFail(); + } + objPtr = ((B3DPrimitiveObject*) (interpreterProxy->firstIndexableField(objOop))); + if (objPtr->magic != B3D_PRIMITIVE_OBJECT_MAGIC) { + return interpreterProxy->primitiveFail(); + } + objPtr->__oop__ = objOop; + objArray[i] = objPtr; + } +} + +static sqInt loadPrimitiveLightSource(void) { + lightFlags = (((int*) primLight))[PrimLightFlags]; +} + + +/* Load the necessary values from the current primitive vertex */ + +static sqInt loadPrimitiveVertex(void) { + sqInt rgba; + + rgba = (((int*) litVertex))[PrimVtxColor32]; + vtxInColor[2] = ((rgba & 255) * (1.0 / 255.0)); + rgba = ((usqInt) rgba) >> 8; + vtxInColor[1] = ((rgba & 255) * (1.0 / 255.0)); + rgba = ((usqInt) rgba) >> 8; + vtxInColor[0] = ((rgba & 255) * (1.0 / 255.0)); + rgba = ((usqInt) rgba) >> 8; + vtxInColor[3] = ((rgba & 255) * (1.0 / 255.0)); +} + + +/* Load the rasterizer state from the given stack index. */ + +static sqInt loadRasterizerState(sqInt stackIndex) { + sqInt obj; + sqInt objLen; + void *objPtr; + sqInt stateOop; + + if ((copyBitsFn == 0) || (loadBBFn == 0)) { + if (!(initialiseModule())) { + return 0; + } + } + stateOop = interpreterProxy->stackObjectValue(stackIndex); + if (interpreterProxy->failed()) { + return 0; + } + if (!((interpreterProxy->isPointers(stateOop)) && ((interpreterProxy->slotSizeOf(stateOop)) >= 10))) { + return 0; + } + obj = interpreterProxy->fetchPointerofObject(0, stateOop); + if (((obj & 1)) || (!(interpreterProxy->isWords(obj)))) { + return 0; + } + objPtr = interpreterProxy->firstIndexableField(obj); + state.faceAlloc = objPtr; + obj = interpreterProxy->fetchPointerofObject(1, stateOop); + if (((obj & 1)) || (!(interpreterProxy->isWords(obj)))) { + return 0; + } + objPtr = interpreterProxy->firstIndexableField(obj); + state.edgeAlloc = objPtr; + obj = interpreterProxy->fetchPointerofObject(2, stateOop); + if (((obj & 1)) || (!(interpreterProxy->isWords(obj)))) { + return 0; + } + objPtr = interpreterProxy->firstIndexableField(obj); + state.attrAlloc = objPtr; + obj = interpreterProxy->fetchPointerofObject(3, stateOop); + if (((obj & 1)) || (!(interpreterProxy->isWords(obj)))) { + return 0; + } + objPtr = interpreterProxy->firstIndexableField(obj); + state.aet = objPtr; + obj = interpreterProxy->fetchPointerofObject(4, stateOop); + if (((obj & 1)) || (!(interpreterProxy->isWords(obj)))) { + return 0; + } + objPtr = interpreterProxy->firstIndexableField(obj); + state.addedEdges = objPtr; + obj = interpreterProxy->fetchPointerofObject(5, stateOop); + if (((obj & 1)) || (!(interpreterProxy->isWords(obj)))) { + return 0; + } + objPtr = interpreterProxy->firstIndexableField(obj); + state.fillList = objPtr; + obj = interpreterProxy->fetchPointerofObject(6, stateOop); + if (obj == (interpreterProxy->nilObject())) { + state.nObjects = 0; + state.objects = NULL; + } else { + if (((obj & 1)) || (!(interpreterProxy->isWords(obj)))) { + return 0; + } + objLen = interpreterProxy->slotSizeOf(obj); + objPtr = interpreterProxy->firstIndexableField(obj); + state.objects = (B3DPrimitiveObject **)objPtr; + state.nObjects = objLen; + } + obj = interpreterProxy->fetchPointerofObject(7, stateOop); + if (obj == (interpreterProxy->nilObject())) { + state.nTextures = 0; + state.textures = NULL; + } else { + if (((obj & 1)) || (!(interpreterProxy->isWords(obj)))) { + return 0; + } + objLen = interpreterProxy->byteSizeOf(obj); + objPtr = interpreterProxy->firstIndexableField(obj); + state.textures = (B3DTexture *)objPtr; + state.nTextures = objLen / sizeof(B3DTexture); + } + obj = interpreterProxy->fetchPointerofObject(8, stateOop); + if (obj == (interpreterProxy->nilObject())) { + state.spanSize = 0; + state.spanBuffer = NULL; + } else { + if (!((interpreterProxy->fetchClassOf(obj)) == (interpreterProxy->classBitmap()))) { + return 0; + } + objLen = interpreterProxy->slotSizeOf(obj); + objPtr = interpreterProxy->firstIndexableField(obj); + state.spanBuffer = (unsigned int *)objPtr; + state.spanSize = objLen; + } + obj = interpreterProxy->fetchPointerofObject(9, stateOop); + if (obj == (interpreterProxy->nilObject())) { + state.spanDrawer = NULL; + } else { + if (!(((int (*) (int))loadBBFn)(obj))) { + return 0; + } + state.spanDrawer = (b3dDrawBufferFunction) copyBitsFn; + } + return !(interpreterProxy->failed()); +} + + +/* Note: This still uses the old-style textures */ + +static sqInt loadTextureinto(sqInt textureOop, B3DTexture *destPtr) { + void *bitsPtr; + sqInt form; + sqInt formBits; + sqInt formDepth; + sqInt formHeight; + sqInt formWidth; + sqInt texEnvMode; + sqInt texInterpolate; + sqInt texWrap; + + form = textureOop; + if (!(interpreterProxy->isPointers(form))) { + return 0; + } + if ((interpreterProxy->slotSizeOf(form)) < 8) { + return 0; + } + formBits = interpreterProxy->fetchPointerofObject(0, form); + formWidth = interpreterProxy->fetchIntegerofObject(1, form); + formHeight = interpreterProxy->fetchIntegerofObject(2, form); + formDepth = interpreterProxy->fetchIntegerofObject(3, form); + texWrap = interpreterProxy->booleanValueOf(interpreterProxy->fetchPointerofObject(5, form)); + texInterpolate = interpreterProxy->booleanValueOf(interpreterProxy->fetchPointerofObject(6, form)); + texEnvMode = interpreterProxy->fetchIntegerofObject(7, form); + if (interpreterProxy->failed()) { + return 0; + } + if ((formWidth < 1) || ((formHeight < 1) || (formDepth != 32))) { + return 0; + } + if (!((interpreterProxy->fetchClassOf(formBits)) == (interpreterProxy->classBitmap()))) { + return 0; + } + if (!((interpreterProxy->byteSizeOf(formBits)) == ((formWidth * formHeight) * 4))) { + return 0; + } + if ((texEnvMode < 0) || (texEnvMode > 1)) { + return 0; + } + + /* Set the texture parameters */ + + bitsPtr = interpreterProxy->firstIndexableField(formBits); + return b3dLoadTexture(destPtr, formWidth, formHeight, formDepth, (unsigned int*) bitsPtr, 0, NULL) == B3D_NO_ERROR; +} + +static sqInt loadTexturesFrom(sqInt stackIndex) { + sqInt arrayOop; + B3DTexture *destPtr; + sqInt i; + sqInt n; + sqInt textureOop; + + arrayOop = interpreterProxy->stackObjectValue(stackIndex); + if (!((interpreterProxy->fetchClassOf(arrayOop)) == (interpreterProxy->classArray()))) { + return interpreterProxy->primitiveFail(); + } + n = interpreterProxy->slotSizeOf(arrayOop); + n = ((n < (state.nTextures)) ? n : (state.nTextures)); + for (i = 0; i <= (n - 1); i += 1) { + destPtr = state.textures + i; + textureOop = interpreterProxy->fetchPointerofObject(i, arrayOop); + if (!(loadTextureinto(textureOop, destPtr))) { + return interpreterProxy->primitiveFail(); + } + } + return 0; +} + + +/* Load the viewport from the given stack index */ + +static sqInt loadViewportFrom(sqInt stackIndex) { + sqInt oop; + sqInt p1; + sqInt p2; + sqInt x0; + sqInt x1; + sqInt y0; + sqInt y1; + + oop = interpreterProxy->stackObjectValue(stackIndex); + if (interpreterProxy->failed()) { + return null; + } + if (!(interpreterProxy->isPointers(oop))) { + return interpreterProxy->primitiveFail(); + } + if ((interpreterProxy->slotSizeOf(oop)) < 2) { + return interpreterProxy->primitiveFail(); + } + p1 = interpreterProxy->fetchPointerofObject(0, oop); + p2 = interpreterProxy->fetchPointerofObject(1, oop); + if (!((interpreterProxy->fetchClassOf(p1)) == (interpreterProxy->classPoint()))) { + return interpreterProxy->primitiveFail(); + } + if (!((interpreterProxy->fetchClassOf(p2)) == (interpreterProxy->classPoint()))) { + return interpreterProxy->primitiveFail(); + } + x0 = interpreterProxy->fetchIntegerofObject(0, p1); + y0 = interpreterProxy->fetchIntegerofObject(1, p1); + x1 = interpreterProxy->fetchIntegerofObject(0, p2); + y1 = interpreterProxy->fetchIntegerofObject(1, p2); + if (interpreterProxy->failed()) { + return null; + } + viewport.x0 = x0; + viewport.y0 = y0; + viewport.x1 = x1; + viewport.y1 = y1; + return 0; +} + +static sqInt mapVBofSizeinto(void *vtxArray, sqInt vtxCount, sqInt boxArray) { + double bottom; + sqInt flags; + sqInt floatOop; + sqInt i; + double left; + sqInt oop; + double right; + double top; + float *vtxPtr; + double w; + double x; + double y; + + vtxPtr = ((float *) vtxArray); + for (i = 1; i <= vtxCount; i += 1) { + flags = (((int *) vtxPtr))[PrimVtxClipFlags]; + w = vtxPtr[PrimVtxRasterPosW]; + if (!(w == 0.0)) { + w = 1.0 / w; + } + if ((flags & OutLeftBit) != 0) { + x = -1.0; + } else { + if ((flags & OutRightBit) != 0) { + x = 1.0; + } else { + x = (vtxPtr[PrimVtxRasterPosX]) * w; + } + } + if ((flags & OutTopBit) != 0) { + y = -1.0; + } else { + if ((flags & OutBottomBit) != 0) { + y = 1.0; + } else { + y = (vtxPtr[PrimVtxRasterPosY]) * w; + } + } + if (i == 1) { + left = right = x; + top = bottom = y; + } + if (x < left) { + left = x; + } + if (x > right) { + right = x; + } + if (y < top) { + top = y; + } + if (y > bottom) { + bottom = y; + } + vtxPtr += PrimVertexSize; + } + oop = boxArray; + interpreterProxy->pushRemappableOop(oop); + floatOop = interpreterProxy->floatObjectOf(left); + oop = interpreterProxy->popRemappableOop(); + interpreterProxy->storePointerofObjectwithValue(0, oop, floatOop); + interpreterProxy->pushRemappableOop(oop); + floatOop = interpreterProxy->floatObjectOf(top); + oop = interpreterProxy->popRemappableOop(); + interpreterProxy->storePointerofObjectwithValue(1, oop, floatOop); + interpreterProxy->pushRemappableOop(oop); + floatOop = interpreterProxy->floatObjectOf(right); + oop = interpreterProxy->popRemappableOop(); + interpreterProxy->storePointerofObjectwithValue(2, oop, floatOop); + interpreterProxy->pushRemappableOop(oop); + floatOop = interpreterProxy->floatObjectOf(bottom); + oop = interpreterProxy->popRemappableOop(); + interpreterProxy->storePointerofObjectwithValue(3, oop, floatOop); +} + + +/* The module with the given name was just unloaded. + Make sure we have no dangling references. */ + +EXPORT(sqInt) moduleUnloaded(char *aModuleName) { + if ((strcmp(aModuleName, bbPluginName)) == 0) { + + /* BitBlt just shut down. How nasty. */ + + loadBBFn = 0; + copyBitsFn = 0; + } +} + +static sqInt msg(char *s) { + fprintf(stderr, "\n%s: %s", moduleName, s); +} + + +/* Primitive. Set the BitBlt plugin to use. */ + +EXPORT(sqInt) primitiveSetBitBltPlugin(void) { + sqInt i; + sqInt length; + sqInt needReload; + sqInt pluginName; + char *ptr; + + + /* Must be string to work */ + + pluginName = interpreterProxy->stackValue(0); + if (!(interpreterProxy->isBytes(pluginName))) { + return interpreterProxy->primitiveFail(); + } + length = interpreterProxy->byteSizeOf(pluginName); + if (length >= 256) { + return interpreterProxy->primitiveFail(); + } + ptr = interpreterProxy->firstIndexableField(pluginName); + needReload = 0; + for (i = 0; i <= (length - 1); i += 1) { + if (!((bbPluginName[i]) == (ptr[i]))) { + bbPluginName[i] = (ptr[i]); + needReload = 1; + } + } + if (!((bbPluginName[length]) == 0)) { + bbPluginName[length] = 0; + needReload = 1; + } + if (needReload) { + if (!(initialiseModule())) { + return interpreterProxy->primitiveFail(); + } + } + interpreterProxy->pop(1); +} + +static double processIndexedofSizeidxArrayidxSize(float *vtxArray, sqInt vtxSize, int *idxArray, sqInt idxSize) { + sqInt i; + sqInt index; + double minZ; + float *vtxPtr; + double wValue; + double zValue; + + minZ = 10.0; + for (i = 1; i <= idxSize; i += 1) { + index = idxArray[i]; + if (index > 0) { + vtxPtr = vtxArray + ((index - 1) * PrimVertexSize); + zValue = vtxPtr[PrimVtxRasterPosZ]; + wValue = vtxPtr[PrimVtxRasterPosW]; + if (!(wValue == 0.0)) { + zValue = zValue / wValue; + } + if (zValue < minZ) { + minZ = zValue; + } + } + } + return minZ; +} + +static sqInt processIndexedIDXofSizeidxArrayidxSize(float *vtxArray, sqInt vtxSize, int *idxArray, sqInt idxSize) { + sqInt i; + sqInt index; + sqInt minIndex; + double minZ; + float *vtxPtr; + double wValue; + double zValue; + + minZ = 10.0; + minIndex = 0; + for (i = 1; i <= idxSize; i += 1) { + index = idxArray[i]; + if (index > 0) { + vtxPtr = vtxArray + ((index - 1) * PrimVertexSize); + zValue = vtxPtr[PrimVtxRasterPosZ]; + wValue = vtxPtr[PrimVtxRasterPosW]; + if (!(wValue == 0.0)) { + zValue = zValue / wValue; + } + if ((minIndex == 0) || (zValue < minZ)) { + minIndex = i; + minZ = zValue; + } + } + } + return minIndex; +} + +static double processNonIndexedofSize(float *vtxArray, sqInt vtxSize) { + sqInt i; + double minZ; + float *vtxPtr; + double wValue; + double zValue; + + minZ = 10.0; + vtxPtr = vtxArray; + for (i = 1; i <= vtxSize; i += 1) { + zValue = vtxPtr[PrimVtxRasterPosZ]; + wValue = vtxPtr[PrimVtxRasterPosW]; + if (!(wValue == 0.0)) { + zValue = zValue / wValue; + } + if (zValue < minZ) { + minZ = zValue; + } + } + return minZ; +} + +static sqInt processNonIndexedIDXofSize(float *vtxArray, sqInt vtxSize) { + sqInt i; + sqInt minIndex; + double minZ; + float *vtxPtr; + double wValue; + double zValue; + + minZ = 10.0; + minIndex = 0; + vtxPtr = vtxArray; + for (i = 1; i <= vtxSize; i += 1) { + zValue = vtxPtr[PrimVtxRasterPosZ]; + wValue = vtxPtr[PrimVtxRasterPosW]; + if (!(wValue == 0.0)) { + zValue = zValue / wValue; + } + if ((minIndex == 0) || (zValue < minZ)) { + minIndex = i; + minZ = zValue; + } + } + return minIndex; +} + +static double rightClipValueFromto(sqInt last, sqInt next) { + return (((((float *) last))[PrimVtxRasterPosX]) - ((((float *) last))[PrimVtxRasterPosW])) / ((((((float *) next))[PrimVtxRasterPosW]) - ((((float *) last))[PrimVtxRasterPosW])) - (((((float *) next))[PrimVtxRasterPosX]) - ((((float *) last))[PrimVtxRasterPosX]))); +} + + +/* Note: This is coded so that is can be run from Squeak. */ + +EXPORT(sqInt) setInterpreter(struct VirtualMachine*anInterpreter) { + sqInt ok; + + interpreterProxy = anInterpreter; + ok = interpreterProxy->majorVersion() == VM_PROXY_MAJOR; + if (ok == 0) { + return 0; + } + ok = interpreterProxy->minorVersion() >= VM_PROXY_MINOR; + return ok; +} + +static sqInt shadeVertex(void) { + double cosAngle; + double specularFactor; + double aPart; + double bPart; + double gPart; + double rPart; + double aPart1; + double bPart1; + double gPart1; + double rPart1; + double aPart2; + double bPart2; + double gPart2; + double rPart2; + double scale; + + /* begin computeDirection */ + if (lightFlags & FlagPositional) { + l2vDirection[0] = ((litVertex[PrimVtxPositionX]) - (primLight[PrimLightPositionX])); + l2vDirection[1] = ((litVertex[PrimVtxPositionY]) - (primLight[PrimLightPositionY])); + l2vDirection[2] = ((litVertex[PrimVtxPositionZ]) - (primLight[PrimLightPositionZ])); + l2vDistance = (((l2vDirection[0]) * (l2vDirection[0])) + ((l2vDirection[1]) * (l2vDirection[1]))) + ((l2vDirection[2]) * (l2vDirection[2])); + if (!((l2vDistance == 0.0) || (l2vDistance == 1.0))) { + l2vDistance = sqrt(l2vDistance); + scale = -1.0 / l2vDistance; + } + l2vDirection[0] = ((l2vDirection[0]) * scale); + l2vDirection[1] = ((l2vDirection[1]) * scale); + l2vDirection[2] = ((l2vDirection[2]) * scale); + } else { + if (lightFlags & FlagDirectional) { + l2vDirection[0] = (primLight[PrimLightDirectionX]); + l2vDirection[1] = (primLight[PrimLightDirectionY]); + l2vDirection[2] = (primLight[PrimLightDirectionZ]); + } + } + /* begin computeAttenuation */ + lightScale = 1.0; + if (lightFlags & FlagAttenuated) { + lightScale = 1.0 / ((primLight[PrimLightAttenuationConstant]) + (l2vDistance * ((primLight[PrimLightAttenuationLinear]) + (l2vDistance * (primLight[PrimLightAttenuationSquared]))))); + } + if (lightFlags & FlagHasSpot) { + lightScale = lightScale * (computeSpotFactor()); + } + if (lightScale > 0.001) { + if (lightFlags & FlagAmbientPart) { + /* begin addPart:from:trackFlag:scale: */ + if (vbFlags & VBTrackAmbient) { + rPart = ((vtxInColor[0]) * ((primLight + AmbientPart)[0])) * lightScale; + gPart = ((vtxInColor[1]) * ((primLight + AmbientPart)[1])) * lightScale; + bPart = ((vtxInColor[2]) * ((primLight + AmbientPart)[2])) * lightScale; + aPart = ((vtxInColor[3]) * ((primLight + AmbientPart)[3])) * lightScale; + } else { + rPart = (((primMaterial + AmbientPart)[0]) * ((primLight + AmbientPart)[0])) * lightScale; + gPart = (((primMaterial + AmbientPart)[1]) * ((primLight + AmbientPart)[1])) * lightScale; + bPart = (((primMaterial + AmbientPart)[2]) * ((primLight + AmbientPart)[2])) * lightScale; + aPart = (((primMaterial + AmbientPart)[3]) * ((primLight + AmbientPart)[3])) * lightScale; + } + vtxOutColor[0] = ((vtxOutColor[0]) + rPart); + vtxOutColor[1] = ((vtxOutColor[1]) + gPart); + vtxOutColor[2] = ((vtxOutColor[2]) + bPart); + vtxOutColor[3] = ((vtxOutColor[3]) + aPart); + } + if (lightFlags & FlagDiffusePart) { + + /* Compute angle from light->vertex to vertex normal */ + /* For one-sided lighting negate cosAngle if necessary */ + + cosAngle = dotProductOfFloatwithDouble(litVertex + PrimVtxNormal, l2vDirection); + if (((vbFlags & VBTwoSidedLighting) == 0) && (cosAngle < 0.0)) { + cosAngle = 0.0 - cosAngle; + } + if (cosAngle > 0.0) { + /* begin addPart:from:trackFlag:scale: */ + if (vbFlags & VBTrackDiffuse) { + rPart1 = ((vtxInColor[0]) * ((primLight + DiffusePart)[0])) * (lightScale * cosAngle); + gPart1 = ((vtxInColor[1]) * ((primLight + DiffusePart)[1])) * (lightScale * cosAngle); + bPart1 = ((vtxInColor[2]) * ((primLight + DiffusePart)[2])) * (lightScale * cosAngle); + aPart1 = ((vtxInColor[3]) * ((primLight + DiffusePart)[3])) * (lightScale * cosAngle); + } else { + rPart1 = (((primMaterial + DiffusePart)[0]) * ((primLight + DiffusePart)[0])) * (lightScale * cosAngle); + gPart1 = (((primMaterial + DiffusePart)[1]) * ((primLight + DiffusePart)[1])) * (lightScale * cosAngle); + bPart1 = (((primMaterial + DiffusePart)[2]) * ((primLight + DiffusePart)[2])) * (lightScale * cosAngle); + aPart1 = (((primMaterial + DiffusePart)[3]) * ((primLight + DiffusePart)[3])) * (lightScale * cosAngle); + } + vtxOutColor[0] = ((vtxOutColor[0]) + rPart1); + vtxOutColor[1] = ((vtxOutColor[1]) + gPart1); + vtxOutColor[2] = ((vtxOutColor[2]) + bPart1); + vtxOutColor[3] = ((vtxOutColor[3]) + aPart1); + } + } + } + if ((lightFlags & FlagSpecularPart) && ((primMaterial[MaterialShininess]) > 0.0)) { + l2vSpecDir[0] = (l2vDirection[0]); + l2vSpecDir[1] = (l2vDirection[1]); + l2vSpecDir[2] = (l2vDirection[2]); + if (vbFlags & VBUseLocalViewer) { + computeSpecularDirection(); + } else { + l2vSpecDir[2] = ((l2vSpecDir[2]) - 1.0); + } + cosAngle = dotProductOfFloatwithDouble(litVertex + PrimVtxNormal, l2vSpecDir); + if (cosAngle > 0.0) { + + /* Normalize the angle */ + /* cosAngle should be somewhere between 0 and 1. + If not, then the vertex normal was not normalized */ + + cosAngle = cosAngle * (inverseLengthOfDouble(l2vSpecDir)); + if (cosAngle > 1.0) { + specularFactor = pow(cosAngle,(primMaterial[MaterialShininess])); + } else { + if (cosAngle == 0.0) { + specularFactor = 1.0; + } else { + specularFactor = pow(cosAngle,(primMaterial[MaterialShininess])); + } + } + /* begin addPart:from:trackFlag:scale: */ + if (vbFlags & VBTrackSpecular) { + rPart2 = ((vtxInColor[0]) * ((primLight + SpecularPart)[0])) * specularFactor; + gPart2 = ((vtxInColor[1]) * ((primLight + SpecularPart)[1])) * specularFactor; + bPart2 = ((vtxInColor[2]) * ((primLight + SpecularPart)[2])) * specularFactor; + aPart2 = ((vtxInColor[3]) * ((primLight + SpecularPart)[3])) * specularFactor; + } else { + rPart2 = (((primMaterial + SpecularPart)[0]) * ((primLight + SpecularPart)[0])) * specularFactor; + gPart2 = (((primMaterial + SpecularPart)[1]) * ((primLight + SpecularPart)[1])) * specularFactor; + bPart2 = (((primMaterial + SpecularPart)[2]) * ((primLight + SpecularPart)[2])) * specularFactor; + aPart2 = (((primMaterial + SpecularPart)[3]) * ((primLight + SpecularPart)[3])) * specularFactor; + } + vtxOutColor[0] = ((vtxOutColor[0]) + rPart2); + vtxOutColor[1] = ((vtxOutColor[1]) + gPart2); + vtxOutColor[2] = ((vtxOutColor[2]) + bPart2); + vtxOutColor[3] = ((vtxOutColor[3]) + aPart2); + } + } +} + + +/* Load an Array of B3DPrimitiveLights from the given stack index */ + +static sqInt stackLightArrayValue(sqInt stackIndex) { + sqInt array; + sqInt arraySize; + sqInt i; + sqInt oop; + + array = interpreterProxy->stackObjectValue(stackIndex); + if (interpreterProxy->failed()) { + return null; + } + if (!((interpreterProxy->fetchClassOf(array)) == (interpreterProxy->classArray()))) { + return interpreterProxy->primitiveFail(); + } + arraySize = interpreterProxy->slotSizeOf(array); + for (i = 0; i <= (arraySize - 1); i += 1) { + oop = interpreterProxy->fetchPointerofObject(i, array); + if ((oop & 1)) { + return interpreterProxy->primitiveFail(); + } + if (!((interpreterProxy->isWords(oop)) && ((interpreterProxy->slotSizeOf(oop)) == PrimLightSize))) { + return interpreterProxy->primitiveFail(); + } + } + return array; +} + + +/* Load a B3DMaterial from the given stack index */ + +static void * stackMaterialValue(sqInt stackIndex) { + sqInt oop; + + oop = interpreterProxy->stackObjectValue(stackIndex); + if (interpreterProxy->failed()) { + return null; + } + if ((interpreterProxy->isWords(oop)) && ((interpreterProxy->slotSizeOf(oop)) == MaterialSize)) { + return interpreterProxy->firstIndexableField(oop); + } + return null; +} + + +/* Load a 4x4 transformation matrix from the interpreter stack. + Return a pointer to the matrix data if successful, nil otherwise. */ + +static void* stackMatrix(sqInt index) { + sqInt oop; + + oop = interpreterProxy->stackObjectValue(index); + if (oop == null) { + return null; + } + if ((interpreterProxy->isWords(oop)) && ((interpreterProxy->slotSizeOf(oop)) == 16)) { + return interpreterProxy->firstIndexableField(oop); + } + return null; +} + + +/* Load a primitive index array from the interpreter stack. + If aBool is true then check that all the indexes are in the range (1,maxIndex). + Return a pointer to the index data if successful, nil otherwise. */ + +static void* stackPrimitiveIndexArrayofSizevalidateforVertexSize(sqInt stackIndex, sqInt nItems, sqInt aBool, sqInt maxIndex) { + sqInt i; + int *idxPtr; + sqInt index; + sqInt oop; + sqInt oopSize; + + oop = interpreterProxy->stackObjectValue(stackIndex); + if (oop == null) { + return null; + } + if (!(interpreterProxy->isWords(oop))) { + return null; + } + oopSize = interpreterProxy->slotSizeOf(oop); + if (oopSize < nItems) { + return null; + } + idxPtr = ((int *) (interpreterProxy->firstIndexableField(oop))); + if (aBool) { + for (i = 0; i <= (nItems - 1); i += 1) { + index = idxPtr[i]; + if ((index < 0) || (index > maxIndex)) { + return null; + } + } + } + return idxPtr; +} + + +/* Load a primitive vertex from the interpreter stack. + Return a pointer to the vertex data if successful, nil otherwise. */ + +static void* stackPrimitiveVertex(sqInt index) { + sqInt oop; + + oop = interpreterProxy->stackObjectValue(index); + if (oop == null) { + return null; + } + if ((interpreterProxy->isWords(oop)) && ((interpreterProxy->slotSizeOf(oop)) == PrimVertexSize)) { + return interpreterProxy->firstIndexableField(oop); + } + return null; +} + + +/* Load a primitive vertex array from the interpreter stack. + Return a pointer to the vertex data if successful, nil otherwise. */ + +static void* stackPrimitiveVertexArrayofSize(sqInt index, sqInt nItems) { + sqInt oop; + sqInt oopSize; + + oop = interpreterProxy->stackObjectValue(index); + if (oop == null) { + return null; + } + if (interpreterProxy->isWords(oop)) { + oopSize = interpreterProxy->slotSizeOf(oop); + if (((oopSize >= nItems) * PrimVertexSize) && ((oopSize % PrimVertexSize) == 0)) { + return interpreterProxy->firstIndexableField(oop); + } + } + return null; +} + +static sqInt storeObjectsInto(sqInt stackIndex) { + sqInt arrayOop; + sqInt arraySize; + sqInt i; + sqInt objOop; + + arrayOop = interpreterProxy->stackObjectValue(stackIndex); + arraySize = state.nObjects; + for (i = 0; i <= (arraySize - 1); i += 1) { + objOop = state.objects[i]->__oop__; + interpreterProxy->storePointerofObjectwithValue(i, arrayOop, objOop); + } +} + + +/* Store the computed output color back into the current primitive vertex. + Clamp the r,g,b,a part to be in the range 0-255. */ + +static sqInt storePrimitiveVertex(void) { + sqInt a; + sqInt b; + sqInt g; + sqInt r; + + r = ((sqInt)((vtxOutColor[0]) * 255)); + r = (((((r < 255) ? r : 255)) < 0) ? 0 : (((r < 255) ? r : 255))); + g = ((sqInt)((vtxOutColor[1]) * 255)); + g = (((((g < 255) ? g : 255)) < 0) ? 0 : (((g < 255) ? g : 255))); + b = ((sqInt)((vtxOutColor[2]) * 255)); + b = (((((b < 255) ? b : 255)) < 0) ? 0 : (((b < 255) ? b : 255))); + a = ((sqInt)((vtxOutColor[3]) * 255)); + + /* The following is equal to b + (g << 8) + (r << 16) + (a << 24) */ + + a = (((((a < 255) ? a : 255)) < 0) ? 0 : (((a < 255) ? a : 255))); + (((int*) litVertex))[PrimVtxColor32] = (b + ((g + ((r + (a << 8)) << 8)) << 8)); +} + +static double topClipValueFromto(sqInt last, sqInt next) { + return (((((float *) last))[PrimVtxRasterPosY]) - ((((float *) last))[PrimVtxRasterPosW])) / ((((((float *) next))[PrimVtxRasterPosW]) - ((((float *) last))[PrimVtxRasterPosW])) - (((((float *) next))[PrimVtxRasterPosY]) - ((((float *) last))[PrimVtxRasterPosY]))); +} + + +/* Transform src with arg into dst. + It is allowed that src == dst but not arg == dst */ + +static sqInt transformMatrixwithinto(float *src, float *arg, float *dst) { + float c1; + float c2; + float c3; + float c4; + sqInt i; + float *m1; + float *m2; + float *m3; + + m1 = ((float *) src); + m2 = ((float *) arg); + m3 = ((float *) dst); + for (i = 0; i <= 3; i += 1) { + + /* Compute next row */ + + c1 = ((((m1[0]) * (m2[0])) + ((m1[1]) * (m2[4]))) + ((m1[2]) * (m2[8]))) + ((m1[3]) * (m2[12])); + c2 = ((((m1[0]) * (m2[1])) + ((m1[1]) * (m2[5]))) + ((m1[2]) * (m2[9]))) + ((m1[3]) * (m2[13])); + c3 = ((((m1[0]) * (m2[2])) + ((m1[1]) * (m2[6]))) + ((m1[2]) * (m2[10]))) + ((m1[3]) * (m2[14])); + + /* Store result */ + + c4 = ((((m1[0]) * (m2[3])) + ((m1[1]) * (m2[7]))) + ((m1[2]) * (m2[11]))) + ((m1[3]) * (m2[15])); + m3[0] = c1; + m3[1] = c2; + m3[2] = c3; + m3[3] = c4; + m1 += 4; + m3 += 4; + } +} + + +/* Transform the normal of the given primitive vertex */ + +static sqInt transformPrimitiveNormalbyrescale(float *pVertex, float *matrix, sqInt rescale) { + double dot; + double rx; + double ry; + double rz; + double x; + double y; + double z; + + x = pVertex[PrimVtxNormalX]; + y = pVertex[PrimVtxNormalY]; + z = pVertex[PrimVtxNormalZ]; + rx = ((x * (matrix[0])) + (y * (matrix[1]))) + (z * (matrix[2])); + ry = ((x * (matrix[4])) + (y * (matrix[5]))) + (z * (matrix[6])); + rz = ((x * (matrix[8])) + (y * (matrix[9]))) + (z * (matrix[10])); + if (rescale) { + dot = ((rx * rx) + (ry * ry)) + (rz * rz); + if (dot < 1.0e-20) { + rx = ry = rz = 0.0; + } else { + if (!(dot == 1.0)) { + dot = 1.0 / (sqrt(dot)); + rx = rx * dot; + ry = ry * dot; + rz = rz * dot; + } + } + } + pVertex[PrimVtxNormalX] = (((float) rx)); + pVertex[PrimVtxNormalY] = (((float) ry)); + pVertex[PrimVtxNormalZ] = (((float) rz)); +} + + +/* Transform the normal of the given primitive vertex */ + +static sqInt transformPrimitivePositionby(float *pVertex, float *matrix) { + double rw; + double rx; + double ry; + double rz; + double x; + double y; + double z; + + x = pVertex[PrimVtxPositionX]; + y = pVertex[PrimVtxPositionY]; + z = pVertex[PrimVtxPositionZ]; + rx = (((x * (matrix[0])) + (y * (matrix[1]))) + (z * (matrix[2]))) + (matrix[3]); + ry = (((x * (matrix[4])) + (y * (matrix[5]))) + (z * (matrix[6]))) + (matrix[7]); + rz = (((x * (matrix[8])) + (y * (matrix[9]))) + (z * (matrix[10]))) + (matrix[11]); + rw = (((x * (matrix[12])) + (y * (matrix[13]))) + (z * (matrix[14]))) + (matrix[15]); + if (rw == 1.0) { + pVertex[PrimVtxPositionX] = (((float) rx)); + pVertex[PrimVtxPositionY] = (((float) ry)); + pVertex[PrimVtxPositionZ] = (((float) rz)); + } else { + if (rw == 0.0) { + rw = 0.0; + } else { + rw = 1.0 / rw; + } + pVertex[PrimVtxPositionX] = (((float) (rx * rw))); + pVertex[PrimVtxPositionY] = (((float) (ry * rw))); + pVertex[PrimVtxPositionZ] = (((float) (rz * rw))); + } +} + + +/* Transform the position of the given primitive vertex assuming that + matrix a41 = a42 = a43 = 0.0 and a44 = 1.0 */ + +static sqInt transformPrimitivePositionFastby(float *pVertex, float *matrix) { + double rx; + double ry; + double rz; + double x; + double y; + double z; + + x = pVertex[PrimVtxPositionX]; + y = pVertex[PrimVtxPositionY]; + z = pVertex[PrimVtxPositionZ]; + rx = (((x * (matrix[0])) + (y * (matrix[1]))) + (z * (matrix[2]))) + (matrix[3]); + ry = (((x * (matrix[4])) + (y * (matrix[5]))) + (z * (matrix[6]))) + (matrix[7]); + rz = (((x * (matrix[8])) + (y * (matrix[9]))) + (z * (matrix[10]))) + (matrix[11]); + pVertex[PrimVtxPositionX] = (((float) rx)); + pVertex[PrimVtxPositionY] = (((float) ry)); + pVertex[PrimVtxPositionZ] = (((float) rz)); +} + + +/* Transform the position of the given primitive vertex assuming that + matrix a14 = a24 = a34 = a41 = a42 = a43 = 0.0 and a44 = 1.0 */ + +static sqInt transformPrimitivePositionFasterby(float *pVertex, float *matrix) { + double rx; + double ry; + double rz; + double x; + double y; + double z; + + x = pVertex[PrimVtxPositionX]; + y = pVertex[PrimVtxPositionY]; + z = pVertex[PrimVtxPositionZ]; + rx = ((x * (matrix[0])) + (y * (matrix[1]))) + (z * (matrix[2])); + ry = ((x * (matrix[4])) + (y * (matrix[5]))) + (z * (matrix[6])); + rz = ((x * (matrix[8])) + (y * (matrix[9]))) + (z * (matrix[10])); + pVertex[PrimVtxPositionX] = (((float) rx)); + pVertex[PrimVtxPositionY] = (((float) ry)); + pVertex[PrimVtxPositionZ] = (((float) rz)); +} + + +/* Transform the normal of the given primitive vertex */ + +static sqInt transformPrimitiveRasterPositionby(float *pVertex, float *matrix) { + double rw; + double rx; + double ry; + double rz; + double x; + double y; + double z; + + x = pVertex[PrimVtxPositionX]; + y = pVertex[PrimVtxPositionY]; + z = pVertex[PrimVtxPositionZ]; + rx = (((x * (matrix[0])) + (y * (matrix[1]))) + (z * (matrix[2]))) + (matrix[3]); + ry = (((x * (matrix[4])) + (y * (matrix[5]))) + (z * (matrix[6]))) + (matrix[7]); + rz = (((x * (matrix[8])) + (y * (matrix[9]))) + (z * (matrix[10]))) + (matrix[11]); + rw = (((x * (matrix[12])) + (y * (matrix[13]))) + (z * (matrix[14]))) + (matrix[15]); + pVertex[PrimVtxRasterPosX] = (((float) rx)); + pVertex[PrimVtxRasterPosY] = (((float) ry)); + pVertex[PrimVtxRasterPosZ] = (((float) rz)); + pVertex[PrimVtxRasterPosW] = (((float) rw)); +} + + +/* Transform the entire vertex array by the given matrices */ +/* TODO: Check the actual trade-offs between vtxCount and analyzing */ + +static sqInt transformVBcountbyandflags(float *vtxArray, sqInt vtxCount, float *modelViewMatrix, float *projectionMatrix, sqInt flags) { + sqInt hasNormals; + sqInt i; + sqInt mvFlags; + float *pVertex; + sqInt prFlags; + sqInt rescale; + + mvFlags = analyzeMatrix(modelViewMatrix); + prFlags = analyzeMatrix(projectionMatrix); + pVertex = ((float *) vtxArray); + + /* Check if we have to rescale the normals */ + + hasNormals = flags & VBVtxHasNormals; + if (hasNormals) { + if (mvFlags & FlagM44Identity) { + rescale = 0; + } else { + rescale = analyzeMatrix3x3Length(modelViewMatrix); + } + } + if ((mvFlags & FlagM44NoPerspective) && (prFlags == 0)) { + if ((mvFlags == FlagM44NoTranslation) == 0) { + for (i = 1; i <= vtxCount; i += 1) { + if (hasNormals) { + transformPrimitiveNormalbyrescale(pVertex, modelViewMatrix, rescale); + } + transformPrimitivePositionFastby(pVertex, modelViewMatrix); + transformPrimitiveRasterPositionby(pVertex, projectionMatrix); + pVertex += PrimVertexSize; + } + } else { + for (i = 1; i <= vtxCount; i += 1) { + if (hasNormals) { + transformPrimitiveNormalbyrescale(pVertex, modelViewMatrix, rescale); + } + transformPrimitivePositionFasterby(pVertex, modelViewMatrix); + transformPrimitiveRasterPositionby(pVertex, projectionMatrix); + pVertex += PrimVertexSize; + } + } + return null; + } + if ((mvFlags & prFlags) & FlagM44Identity) { + for (i = 1; i <= vtxCount; i += 1) { + pVertex[PrimVtxRasterPosX] = (pVertex[PrimVtxPositionX]); + pVertex[PrimVtxRasterPosY] = (pVertex[PrimVtxPositionY]); + pVertex[PrimVtxRasterPosZ] = (pVertex[PrimVtxPositionZ]); + pVertex[PrimVtxRasterPosW] = 1.0; + pVertex += PrimVertexSize; + } + return null; + } + if (mvFlags & FlagM44Identity) { + for (i = 1; i <= vtxCount; i += 1) { + transformPrimitiveRasterPositionby(pVertex, projectionMatrix); + pVertex += PrimVertexSize; + } + return null; + } + if (prFlags & FlagM44Identity) { + for (i = 1; i <= vtxCount; i += 1) { + if (hasNormals) { + transformPrimitiveNormalbyrescale(pVertex, modelViewMatrix, rescale); + } + if (mvFlags == (FlagM44NoPerspective + FlagM44NoPerspective)) { + transformPrimitivePositionFasterby(pVertex, modelViewMatrix); + } else { + if (mvFlags == FlagM44NoPerspective) { + transformPrimitivePositionFastby(pVertex, modelViewMatrix); + } else { + transformPrimitivePositionby(pVertex, modelViewMatrix); + } + } + pVertex[PrimVtxRasterPosX] = (pVertex[PrimVtxPositionX]); + pVertex[PrimVtxRasterPosY] = (pVertex[PrimVtxPositionY]); + pVertex[PrimVtxRasterPosZ] = (pVertex[PrimVtxPositionZ]); + pVertex[PrimVtxRasterPosW] = 1.0; + pVertex += PrimVertexSize; + } + return null; + } + for (i = 1; i <= vtxCount; i += 1) { + if (hasNormals) { + transformPrimitiveNormalbyrescale(pVertex, modelViewMatrix, rescale); + } + transformPrimitivePositionby(pVertex, modelViewMatrix); + transformPrimitiveRasterPositionby(pVertex, projectionMatrix); + pVertex += PrimVertexSize; + } +} + + +/* Load the word based array of size count from the given oop */ + +static void* vbLoadArraysize(sqInt oop, sqInt count) { + if (oop == null) { + interpreterProxy->primitiveFail(); + return null; + } + if (oop == (interpreterProxy->nilObject())) { + return null; + } + if (!(interpreterProxy->isWords(oop))) { + interpreterProxy->primitiveFail(); + return null; + } + if (!((interpreterProxy->slotSizeOf(oop)) == count)) { + interpreterProxy->primitiveFail(); + return null; + } + return interpreterProxy->firstIndexableField(oop); +} + + +#ifdef SQUEAK_BUILTIN_PLUGIN + + +void* Squeak3D_exports[][3] = { + {"Squeak3D", "b3dShaderVersion", (void*)b3dShaderVersion}, + {"Squeak3D", "b3dTransformPrimitiveNormal", (void*)b3dTransformPrimitiveNormal}, + {"Squeak3D", "b3dClipPolygon", (void*)b3dClipPolygon}, + {"Squeak3D", "b3dOrthoNormInverseMatrix", (void*)b3dOrthoNormInverseMatrix}, + {"Squeak3D", "b3dTransformVertexBuffer", (void*)b3dTransformVertexBuffer}, + {"Squeak3D", "b3dComputeMinZ", (void*)b3dComputeMinZ}, + {"Squeak3D", "b3dInitializeRasterizerState", (void*)b3dInitializeRasterizerState}, + {"Squeak3D", "b3dDetermineClipFlags", (void*)b3dDetermineClipFlags}, + {"Squeak3D", "getModuleName", (void*)getModuleName}, + {"Squeak3D", "setInterpreter", (void*)setInterpreter}, + {"Squeak3D", "b3dTransformPrimitiveRasterPosition", (void*)b3dTransformPrimitiveRasterPosition}, + {"Squeak3D", "primitiveSetBitBltPlugin", (void*)primitiveSetBitBltPlugin}, + {"Squeak3D", "b3dTransformMatrixWithInto", (void*)b3dTransformMatrixWithInto}, + {"Squeak3D", "b3dStartRasterizer", (void*)b3dStartRasterizer}, + {"Squeak3D", "b3dShadeVertexBuffer", (void*)b3dShadeVertexBuffer}, + {"Squeak3D", "b3dRasterizerVersion", (void*)b3dRasterizerVersion}, + {"Squeak3D", "b3dInitPrimitiveObject", (void*)b3dInitPrimitiveObject}, + {"Squeak3D", "b3dLoadVertexBuffer", (void*)b3dLoadVertexBuffer}, + {"Squeak3D", "b3dTransformDirection", (void*)b3dTransformDirection}, + {"Squeak3D", "moduleUnloaded", (void*)moduleUnloaded}, + {"Squeak3D", "b3dPrimitiveTextureSize", (void*)b3dPrimitiveTextureSize}, + {"Squeak3D", "b3dComputeMinIndexZ", (void*)b3dComputeMinIndexZ}, + {"Squeak3D", "b3dMapVertexBuffer", (void*)b3dMapVertexBuffer}, + {"Squeak3D", "initialiseModule", (void*)initialiseModule}, + {"Squeak3D", "b3dTransformerVersion", (void*)b3dTransformerVersion}, + {"Squeak3D", "b3dTransposeMatrix", (void*)b3dTransposeMatrix}, + {"Squeak3D", "b3dPrimitiveNextClippedTriangle", (void*)b3dPrimitiveNextClippedTriangle}, + {"Squeak3D", "b3dTransformPoint", (void*)b3dTransformPoint}, + {"Squeak3D", "b3dTransformPrimitivePosition", (void*)b3dTransformPrimitivePosition}, + {"Squeak3D", "b3dPrimitiveObjectSize", (void*)b3dPrimitiveObjectSize}, + {"Squeak3D", "b3dLoadIndexArray", (void*)b3dLoadIndexArray}, + {"Squeak3D", "b3dInplaceHouseHolderInvert", (void*)b3dInplaceHouseHolderInvert}, + {NULL, NULL, NULL} +}; + + +#endif /* ifdef SQ_BUILTIN_PLUGIN */ + Modified: trunk/platforms/unix/src/plugins.ext =================================================================== --- trunk/platforms/unix/src/plugins.ext 2011-01-23 07:34:41 UTC (rev 2354) +++ trunk/platforms/unix/src/plugins.ext 2011-01-23 09:41:21 UTC (rev 2355) @@ -1,2 +1,2 @@ # Automatically generated makefile include for external plugins -EXTERNAL_PLUGINS = B3DAcceleratorPlugin ClipboardExtendedPlugin DBusPlugin SqueakFFIPrims FileCopyPlugin GStreamerPlugin HostWindowPlugin KedamaPlugin KedamaPlugin2 MIDIPlugin Mpeg3Plugin UUIDPlugin AioPlugin UnixOSProcessPlugin XDisplayControlPlugin +EXTERNAL_PLUGINS = B3DAcceleratorPlugin Squeak3D ClipboardExtendedPlugin DBusPlugin SqueakFFIPrims FileCopyPlugin GStreamerPlugin HostWindowPlugin KedamaPlugin KedamaPlugin2 MIDIPlugin Mpeg3Plugin RomePlugin UUIDPlugin AioPlugin UnixOSProcessPlugin XDisplayControlPlugin Modified: trunk/platforms/unix/src/vm/intplugins/ADPCMCodecPlugin/ADPCMCodecPlugin.c =================================================================== --- trunk/platforms/unix/src/vm/intplugins/ADPCMCodecPlugin/ADPCMCodecPlugin.c 2011-01-23 07:34:41 UTC (rev 2354) +++ trunk/platforms/unix/src/vm/intplugins/ADPCMCodecPlugin/ADPCMCodecPlugin.c 2011-01-23 09:41:21 UTC (rev 2355) @@ -1,4 +1,4 @@ -/* Automatically generated from Squeak on 23 January 2011 3:55:22 pm +/* Automatically generated from Squeak on 23 January 2011 6:33:58 pm by VMMaker 4.4.7 */ Modified: trunk/platforms/unix/src/vm/intplugins/SoundGenerationPlugin/SoundGenerationPlugin.c =================================================================== --- trunk/platforms/unix/src/vm/intplugins/SoundGenerationPlugin/SoundGenerationPlugin.c 2011-01-23 07:34:41 UTC (rev 2354) +++ trunk/platforms/unix/src/vm/intplugins/SoundGenerationPlugin/SoundGenerationPlugin.c 2011-01-23 09:41:21 UTC (rev 2355) @@ -1,4 +1,4 @@ -/* Automatically generated from Squeak on 23 January 2011 3:55:48 pm +/* Automatically generated from Squeak on 23 January 2011 6:34:01 pm by VMMaker 4.4.7 */ Modified: trunk/platforms/unix/src/vm/sqNamedPrims.h =================================================================== --- trunk/platforms/unix/src/vm/sqNamedPrims.h 2011-01-23 07:34:41 UTC (rev 2354) +++ trunk/platforms/unix/src/vm/sqNamedPrims.h 2011-01-23 09:41:21 UTC (rev 2355) @@ -1,4 +1,4 @@ -/* Automatically generated from Squeak on 23 January 2011 3:55:49 pm +/* Automatically generated from Squeak on 23 January 2011 6:34:01 pm by VMMaker 4.4.7 */ /* This is an automatically generated table of all builtin modules in the VM */ |
«
Return to Squeak VM
|
1 view|%1 views
| Free forum by Nabble | Edit this page |