4.Coordinate transformation

This chapter explains the basic idea of 3D graphics and the subroutines that realize it. In addition, in this chapter, we will mainly proceed with the discussion using a mathematical method called coordinate transformation. It may be difficult to understand as it uses a lot of slightly different techniques than usual, such as calculating determinants, but it is the basics of 3D graphics, so please read it many times to understand it.
Objects displayed in 3D graphics are generally defined by the following four things.

• Coordinate system → determines the position and orientation of objects and viewpoints.
• Projection transformation → Define how the image is projected on the projection surface.
• Modeling Transformations → Define translation, rotation, and scaling within a coordinate system.
• Viewing transformation → Define the viewpoint and its movement (see “ Chapter 6 Camera ” for details).

By combining these four elements, 3D graphics makes it possible to display images on a monitor. Therefore, in this chapter, we will explain each of the three, excluding viewing conversion, in order, and then add more detailed explanations.

4-1. Coordinate system

The Sega Saturn uses a 3D coordinate system, commonly referred to as a right-handed coordinate system. This refers to a coordinate system in which when the positive direction of the Z axis is placed at the back of the screen, the positive direction of the Y axis is at the bottom of the screen, and the positive direction of the X axis is at the right side of the screen. Also, the positive direction of rotation is to the right (clockwise) with respect to the axis.

＜ Figure 4-1 Coordinate system used by Sega Saturn＞

Additionally, SGL has a 2D coordinate system called screen coordinates that corresponds to the TV monitor and screen mode (resolution). This is mainly used to handle 2D graphics such as scrolling and sprites, but it is also used when setting windows in “ 4-5 Window ”.

＜ Figure 4-2 Screen coordinate system＞

4-2. Projection transformation

Explains how coordinates appear on screen and explains how to set up projections.

Perspective ProjectionThis section describes perspective projection, which is the basis of transformations. First, set the viewpoint, and the figure below shows the projection result when there is a cube placed perpendicular to the line of sight on the extension of that viewpoint.

＜ Figure 4-3 Concept of projection＞

In perspective projection, the image is defined as a mapping onto a plane called the projection plane. Think of the projection surface as a screen on which a shadow puppet is projected.
The object point is drawn where the line segment connecting the viewpoint and the object point intersects the projection plane. By performing this operation on all object points in the space, the space will be drawn on the projection plane.

Figure 4-4 Projection plane in SGL

The projection surface in SGL refers to the TV monitor. Objects placed in the virtual 3D space are projected in perspective, then mapped to the screen coordinate system and drawn on the TV monitor.

viewing volume

The area projected onto the projection plane is called the viewing volume.
In the case of SGL, there are two parameters that control this viewing volume: angle of view and display level.
Here, we will introduce two of them.

1) Angle of view

Perspective is a parameter that determines how wide the image is projected in the horizontal direction from the viewpoint as the origin.
Increasing this value will increase the density of objects projected onto the projection surface, creating an image similar to that seen through a fisheye lens.
Note that the vertical spread is determined by the viewing angle value and the resolution depending on the screen mode.

＜ Figure 4-5 Viewing angle image model＞

To change perspective projection settings on SGL, use the function “slPerspective”.

[void slPerspective (ANGLE perspective_angle);]

By varying the parameters of this function, you can control the spatial region projected onto the projection plane.
The parameters include an angular value (10＜ angle＜ 160). Exceeding this value range will result in an overflow.

＜ Figure 4-6 Differences in images due to angle of view values＞

2) Display level

The display level is a parameter that determines how much of the area behind the projection surface is projected onto the projection surface.
Objects behind the projection surface are also projected onto the projection surface in the same way as images behind the projection surface.

The display level is set using the function “slZdspLevel”.
The display level is determined by the point of view and the dividing point of the projection plane from which the image is projected.

[void slZdspLevel (Uint16 level);]

Determines the display level of the viewing volume.
Assign the values in the table below to the parameters according to the display level.

Table 4-1 Display level substitution value (level)

	display level
	1/2	1/4	1/8
Substitution value	1	2	3

The figure below is an image model of the display level.

Figure 4-7 Display level

Listing 4-1 below shows how the cube looks by placing it in the center of the screen and varying the viewing angle value, which is a perspective parameter, between 20 and 160 degrees.

List 4-1 sample_4_2: Changes in video due to perspective

/*------------------------------------------------ ----------------------*/
/* Perspective Control */
/*------------------------------------------------ ----------------------*/
#include "sgl.h"

extern PDATA PD_CUBE;

void ss_main(void){
	static ANGLE ang[XYZ];
	static ANGLE angper[XYZ];
	static FIXED pos[XYZ];
	static ANGLE tmp = DEGtoANG(90.0);
	static ANGLE adang = DEGtoANG(0.5);

	slInitSystem(TV_320x224,NULL,1);
	slPrint("Sample program 4.2" , slLocate(6,2));

	ang[X] = DEGtoANG(30.0);
	ang[Y] = DEGtoANG(45.0);
	ang[Z] = DEGtoANG( 0.0);
	pos[X] = toFIXED(50.0);
	pos[Y] = toFIXED(40.0);
	pos[Z] = toFIXED(20.0);

	slPrint("Perspective : " , slLocate(4,5));
	while(-1){
		slPerspective(tmp);
		slPrintHex(slAng2Dec(tmp) , slLocate(18,5));

		tmp +=adang;
		if (tmp> DEGtoANG(160.0)) 
			adang = DEGtoANG(-0.5);
		if (tmp< DEGtoANG(20.0))
			adang = DEGtoANG(0.5);

		slPushMatrix();
		{
			FIXED dz;

			dz = slDivFX(slTan(tmp>> 1), toFIXED(170.0));
			slTranslate(pos[X] , pos[Y] , pos[Z] + dz);
			slRotX(ang[X]);
			slRotY(ang[Y]);
			slRotZ(ang[Z]);
			slPutPolygon(&PD_CUBE);
		}
		slPopMatrix();

		slSynch();
	}
}

Flow 4-1 sample_4_2: Flowchart of image changes by perspective

4-3. Modeling conversion

This section describes the placement and transformation of objects in space. There are three types of transformations for objects: movement, rotation, and scaling.
By using this, objects can be placed freely.
Next, we will explain each conversion operation in order with sample programs.

＜ Figure 4-8 Various conversion operations on objects＞

Note) Angles and variables are shown in degrees and floating for convenience.

Rotating an object

To rotate an object in space, use the library functions “slRotX, slRotY, slRotZ”. Controls the rotation corresponding to the coordinate axis at the end of each function name.
Rotating an object is achieved by multiplying each vertex coordinate of the object by a transformation matrix called a rotation matrix.

[void slRotX (ANGLE angx);]

Adds rotation around the X axis to the object. Assign the rotation angle value to the parameter.

[void slRotY (ANGLE angy);]

Adds rotation around the Y axis to the object. Assign the rotation angle value to the parameter.

[void slRotZ (ANGLE angz);]

Adds rotation around the Z axis to the object. Assign the rotation angle value to the parameter.

List 4-2 below is a program that uses the library function "slRotY" to rotate the square polygon drawn in List 2-1 in Chapter 2 on the Y axis (single-axis rotation). The rotation matrix is expressed as:

＜ Listing 4-2 sample_4_3_1: Square polygon single axis rotation routine＞

/*------------------------------------------------ ----------------------*/
/* Rotation of 1 Polygon [Y axis] */
/*------------------------------------------------ ----------------------*/
#include "sgl.h"

extern PDATA PD_PLANE1;

void ss_main(void)
{
	static ANGLE ang[XYZ];
	static FIXED pos[XYZ];

	slInitSystem(TV_320x224,NULL,1);
	slPrint("Sample program 4.3.1" , slLocate(9,2));

	ang[X] = ang[Y] = ang[Z] = DEGtoANG(0.0);
	pos[X] = toFIXED( 0.0);
	pos[Y] = toFIXED( 0.0);
	pos[Z] = toFIXED(220.0);

	while(-1){
		slPushMatrix();
		{
			slTranslate(pos[X] , pos[Y] , pos[Z]);
			slRotX(ang[X]);
			slRotY(ang[Y]);
			slRotZ(ang[Z]);
			ang[Y] += DEGtoANG(5.0);
			slPutPolygon(&PD_PLANE1);
		}
		slPopMatrix();

		slSynch();
	}
}

Flow 4-2 sample_4_3_1: Square polygon single axis rotation routine flowchart

List 4-3 below is a program to realize two-axis rotation. Rotates a square polygon around two axes: the X and Y axes.
The actual operations are the same for single-axis rotation, 2-axis rotation, or 3-axis rotation. By manipulating the angle value of the rotation function corresponding to each axis, the object is drawn with rotation applied to it.

List 4-3 sample_4_3_2: Square polygon 2-axis rotation routine

/*------------------------------------------------ ----------------------*/
/* Rotation of 1 Polygon [X & Y axis] */
/*------------------------------------------------ ----------------------*/
#include "sgl.h"

extern PDATA PD_PLANE1;

void ss_main(void)
{
	static ANGLE ang[XYZ];
	static FIXED pos[XYZ];

	slInitSystem(TV_320x224,NULL,1);
	slPrint("Sample program 4.3.2" , slLocate(9,2));

	ang[X] = ang[Y] = ang[Z] = DEGtoANG(0.0);
	pos[X] = toFIXED( 0.0);
	pos[Y] = toFIXED( 0.0);
	pos[Z] = toFIXED(220.0);

	while(-1){
		slPushMatrix();
		{
			slTranslate(pos[X] , pos[Y] , pos[Z]);
			slRotX(ang[X]);
			slRotY(ang[Y]);
			slRotZ(ang[Z]);
			ang[X] += DEGtoANG(4.0);
			ang[Y] += DEGtoANG(2.0);
			slPutPolygon(&PD_PLANE1);
		}
		slPopMatrix();

		slSynch();
	}
}

Moving objects

To move objects in space with SGL, use the library function “slTranslate”.
By substituting the amount of movement for each XYZ axis from the current point as a parameter, you can display the object at any coordinate in 3D space.

[void slTranslate ( FIXED tx , ty , tz );]

Moves the object to the specified coordinates and displays it.
Assign the amount of movement from the defined coordinates or local point to each of the X, Y, and Z axes to the parameters.

Listing 4-4 below uses the library function “slTranslate” to achieve translation parallel to the X axis. The Sin value is used to control the movement parameters. Changes in the angle value tmp control changes in the X coordinate value.
Parallel translation using “slTranslate” is expressed by the following formula.

Listing 4-4 sample_4_3_3: Square polygon parallel movement routine

/*------------------------------------------------ ----------------------*/
/* Parallel Translation of 1 Polygon [X axis] */
/*------------------------------------------------ ----------------------*/
#include "sgl.h"

#define POS_Z 50.0

extern PDATA PD_PLANE1;

void ss_main(void)
{
	static ANGLE ang[XYZ];
	static FIXED pos[XYZ];
	static ANGLE tmp = DEGtoANG(0.0);

	slInitSystem(TV_320x224,NULL,1);
	slPrint("Sample program 4.3.3" , slLocate(9,2));

	ang[X] = ang[Y] = ang[Z] = DEGtoANG(0.0);
	pos[X] = toFIXED( 0.0);
	pos[Y] = toFIXED( 0.0);
	pos[Z] = toFIXED(220.0);

	while(-1){
		slPushMatrix();
		{
			slTranslate(pos[X] , pos[Y] , pos[Z]);
			slRotX(ang[X]);
			slRotY(ang[Y]);
			slRotZ(ang[Z]);
			tmp += DEGtoANG(5.0);
			pos[X] = slMulFX(toFIXED(POS_Z), slSin(tmp));
			slPutPolygon(&PD_PLANE1);
		}
		slPopMatrix();

		slSynch();
	}
}

＜Flow 4-3 sample_4_3_3: Square polygon parallel movement flowchart＞

Scaling objects

To scale objects in space with SGL, use the library function "slScale". Parameters are passed as scale ratios along each axis.

[void slScale ( FIXED sx , sy , sz );]

Displays the object scaled by each axis.
Substitute the scale value (arbitrary magnification) for each of the XYZ axes into the parameters.
The object changes depending on the scale value as shown in the table below.

Table 4-2 Changes in objects depending on scale value

	Parameter range
	scale＜ 0.0	scale=0.0	0.0＜ scale＜ 1.0	scale=1.0	1.0＜ scale
Conversion result	mirror image	Disappearance	reduction	Same size	expansion

Note) “Scale” refers to the scale parameter.

Change of object by scale value

If the scale value is 0.0, the object will be drawn as having no thickness along the axis specified by the scale.
Also, for negative values less than 0.0, the object will be drawn as a mirror image with respect to the scaled axis direction.

Listing 4-5 below is a program that accomplishes scaling. The scale ratio of the square polygon in the X-axis direction and Y-axis direction is changed.

Listing 4-5 sample_4_3_4: Square polygon scaling routine

/*------------------------------------------------ ----------------------*/
/* Expansion & Reduction of 1 Polygon [X & Y axis] */
/*------------------------------------------------ ----------------------*/
#include "sgl.h"

extern PDATA PD_PLANE1;

void ss_main(void)
{
	static ANGLE ang[XYZ];
	static FIXED pos[XYZ];
	static FIXED sclx, scly, sclz, tmp = toFIXED(0.0);
	static Sint16 flag = 1;

	slInitSystem(TV_320x224,NULL,1);
	slPrint("Sample program 4.3.4" , slLocate(9,2));

	ang[X] = ang[Y] = ang[Z] = DEGtoANG(0.0);
	pos[X] = toFIXED( 0.0);
	pos[Y] = toFIXED( 0.0);
	pos[Z] = toFIXED(220.0);
	sclx = scly = sclz = toFIXED(1.0);

	while(-1){
		slPushMatrix();
		{
			slTranslate(pos[X] , pos[Y] , pos[Z]);
			slRotX(ang[X]);
			slRotY(ang[Y]);
			slRotZ(ang[Z]);
			if (flag == 1) tmp += toFIXED(0.1);
			else tmp -= toFIXED(0.1);
			if (tmp > toFIXED( 1.0)) flag = 0;
			if (tmp < toFIXED(-1.0)) flag = 1;
			slScale(sclx + tmp, scly - tmp, sclz);
			slPutPolygon(&PD_PLANE1);
		}
		slPopMatrix();

		slSynch();
	}
}

＜Flow 4-4 sample_4_3_4: Square polygon scaling flowchart＞

Special modeling transformations

Here we introduce library functions that perform slightly specialized modeling transformation operations. The functions introduced here all perform rotation operations on object data, but the parameter settings differ from the rotation operation library functions described above.

[void slRotXSC (FIXED sin, FIXED cos);]

Substitute the sine and cosine values and add rotation around the X axis.
Assign the Sin and Cos values to the parameters as FIXED type numbers.

[void slRotYSC (FIXED sin, FIXED cos);]

Substitute the sine and cosine values and add rotation around the Y axis
Assign the Sin and Cos values to the parameters as FIXED type numbers.

[void slRotZSC (FIXED sin, FIXED cos);]

Substitute the sine and cosine values and add rotation around the Z axis.
Assign the Sin and Cos values to the parameters as FIXED type numbers.

[void slRotAX (VECTOR vx, vy, vz, ANGLE anga);]

Adds rotation around an arbitrary axis passing through the origin (axis units are specified as vector values).
Assign the unit vector value (XYZ) representing the rotation axis and rotation angle value to the parameters.
Always substitute a value that is a unit vector for the vector value representing the rotation axis.
A unit vector is a vector whose magnitude is always 1.

Differences in results due to conversion order

In the case of 3D graphics, various transformations, such as modeling transformations, are performed using a transformation matrix called a matrix. Therefore, unless you understand the order of transformations before performing transformation operations, objects may be drawn with different results than you intended. The following images both show rotation and translation transformation operations, but because the transformation order is different, the final drawing results are very different.

＜ Figure 4-9 Differences in results depending on conversion order＞

Note) Angles and variables are shown in degrees and floating for convenience.

4-4. Clipping

Clipping is the process of removing and hiding the parts that protrude from the display area (the area that is actually projected onto the projection surface). In SGL, you can use this concept to set a window on the projection surface. Therefore, I will first explain the concept of clipping, and then explain the actual window settings on SGL.

2D clipping

First, we will explain the concept of clipping using an example of 2D graphics. In the case of 2D graphics, display/non-display can be switched between inside and outside the divided rectangular area.
The example below shows a display example when objects to be displayed are placed inside and outside the display area given as a rectangular area.

＜ Figure 4-10 Example of 2D clipping＞

Note) When the display area is a projection plane closed by clipping boundaries

As shown in the image above, objects targeted for clipping can be shown or hidden inside and outside the clipping area. In this example, if one object covers both sides of the clipping area, part of the object (inside the area) will be visible, and part (outside the area) will not be displayed.

Note
In some cases, due to problems with calculation speed and drawing speed, display or non-display may be switched depending on the percentage of one object included in the clipping area.

3D clipping

In 3D graphics, a viewing pyramid is usually determined using a perspective transformation matrix, and the area inside this pyramid is defined as the display area, and the area outside the pyramid is defined as a non-display area. Objects within the display area are projected onto the projection surface and displayed on the monitor.
This viewing pyramid is clipped by a closed space (viewing volume) surrounded by the following six planes:

left side of visual field	: Clipping plane (determined by angle of view value)
right side of field of vision	: Clipping plane (determined by angle of view value)
top of field of view	: Clipping plane (determined by angle of view value and screen mode)
lower surface of the field of vision	: Clipping plane (determined by angle of view value and screen mode)
front of field of view	: Front limit surface (determined by function “slZdspLevel”)
posterior aspect of visual field	: Backward limit surface (determined by parameter “Zlimit” in function “slWindow”)

In addition to this, in SGL it is possible to add additional clipping planes (see Section 4.5: Windows for details).

Figure 4-11 Defining the display area by 3D clipping

Figure 4-12 Example of 3D clipping

4-5. Window

In SGL, using the concept of clipping, a rectangular area called a window for display restriction can be set on the projection plane. Objects can be shown or hidden inside and outside this area.
Up to two windows can be held on one screen. One of these windows is set as the default window from the beginning. This window is the same size as the projection screen (TV monitor) and can be reset during the program.

window concept

In SGL, windows are defined as shown below.

＜ Figure 4-13 Window concept＞

In SGL, a window is defined as a rectangular area in the projection plane. Interpreting this three-dimensionally, it refers to the area in the viewing volume that should be projected onto the rectangular area of the projection plane (dark shaded area in the figure). By specifying the window area, you can decide whether to display or hide objects inside or outside of this area.
The window size can be set up to the same size as the projection surface.

Window settings in SGL

To actually set the window in SGL, use the library function “slWindow”. Also, in the initial state (without using slWindow), SGL has already set a reconfigurable default window of the same size as the projection plane.

[void slWindow (left, top, right, bottom, Zlimit, CENTER_X, CENTER_Y);]

The library function slWindow sets the window area on the projection plane. Each parameter sets the screen coordinates of the upper left and lower right of the window on the projection plane, the rear limit coordinates, and the screen coordinates that determine the viewing direction. The figure below illustrates each parameter.

Figure 4-14 Meaning of parameters in “slWindow”

Note) left, top, right, bottom, CENTER_X, CENTER_Y indicate the XY coordinate values for the monitor.

The parameters of the library function “slWindow” are defined as follows.

[Sint16 left, top, right, bottom]

Indicates the screen coordinate values of the upper left and lower right of the window's projection plane (monitor).
The range of values depends on the screen mode (maximum value is full resolution depending on the screen mode).
In the default window, the window size and monitor size are set to be the same (maximum value).

[Zlimit]

Specifies the projection limits of the window.
The projection limit value is a parameter that determines how deep the space from the front limit surface specified by the function "slZdspLevel" is actually projected onto the projection plane (specifying the rear limit surface). .
If “Zlimit = -1” is assigned, the Zlimit value of the most recently set window will be used.
If no window was previously set, the default window value (7FFF) is used.

[CENTER_X, CENTER_Y]

This determines the viewing direction, and the parameters are expressed as screen coordinate values. By changing this value, you can determine where on the screen the distant objects will converge.
This point is generally called the "vanishing point" in the world of 3D graphics.
In the default window, the "vanishing point" is set to the center of the screen.

About screen coordinates

Screen coordinates are a 2D coordinate system that corresponds to the TV monitor, which is the projection surface.
The upper left is the origin, the X-axis is to the right, and the Y-axis is to the bottom. The value range varies depending on the screen mode, but is usually expressed as (width: 320 x height: 224).

Figure 4-15 Difference in images due to CENTER_X and CENTER_Y

Note) Conditions such as object and viewpoint are the same for both a) and b)

Resetting the default window

If you want to set the default window again after rewriting the default window for some reason, enter the following value in the library function "slWindow".
However, in the example below, the screen size is assumed to be (320 width x 224 height).

Figure 4-16 Resetting the default window

●For screen mode (320 horizontal x 240 vertical)

slWindow(0,0,319,223,0x7FFF,160,112);
         |           |      |
         |           |      Vanishing point coordinates: center of screen
         |           Zlimit
         Window range indication coordinate value

The default window is a window that is the same size as your monitor.
The window size is the same size as the monitor (the value changes depending on the screen mode), the rear limit coordinate value is “0x7FFF”, and the vanishing point is set at the center of the monitor.

sample program

The figure below is an example of how objects are displayed using the sample program “sample_4_5” that uses windows. Object 1 is a rectangular plate polygon and object 2 is a cubic polygon, and they are arranged so that they intersect each other at a certain Z coordinate.
The display shown in d) in the figure below is when a window is set using the library function “slWindow”. Object 1 is set to display outside the window area, and object 2 is set to display within the window area (this setting is explained below).

Figure 4-17 Example of object display using a window

Note 1) Object 1 is displayed outside the window
Note 2) Object 2 is displayed in the window

SGL allows you to show and hide objects inside and outside the window. This switching can be set for each polygon surface as a polygon attribute.
The details will be given in “Chapter 7: Polygon Surface Attributes”, but here we will introduce the part that corresponds to the polygon surface attributes in the data file “polygon.c” used in the sample program.

Listing 4-7 polygon.c: Polygon attributes related to window display

/* Foreword omitted */

ATTR attribute_PLANE[] = {
	ATTRIBUTE(Single_Plane, SORT_MIN, No_Texture, C_RGB(16,16,16), No_Gouraud, MESHoff|Window_Out, sprPolygon,No_Option),
	ATTRIBUTE(Single_Plane, SORT_MIN, No_Texture, C_RGB(00,31,31), No_Gouraud, MESHoff|Window_Out, sprPolygon,No_Option),
};

ATTR attribute_CUBE[] = {
	ATTRIBUTE(Single_Plane, SORT_MIN, No_Texture, C_RGB(31,31,31), No_Gouraud, MESHoff|Window_In, sprPolygon,No_Option),
	ATTRIBUTE(Single_Plane, SORT_MIN, No_Texture, C_RGB(31,00,00), No_Gouraud, MESHoff|Window_In, sprPolygon,No_Option),
	ATTRIBUTE(Single_Plane, SORT_MIN, No_Texture, C_RGB(00,31,00), No_Gouraud, MESHoff|Window_In, sprPolygon,No_Option),
	ATTRIBUTE(Single_Plane, SORT_MIN, No_Texture, C_RGB(00,00,31), No_Gouraud, MESHoff|Window_In, sprPolygon,No_Option),
	ATTRIBUTE(Single_Plane, SORT_MIN, No_Texture, C_RGB(31,31,00), No_Gouraud, MESHoff|Window_In, sprPolygon,No_Option),
	ATTRIBUTE(Single_Plane, SORT_MIN, No_Texture, C_RGB(00,31,31), No_Gouraud, MESHoff|Window_In, sprPolygon,No_Option),
};

/* omitted */

Range of influence by window

The function “slWindow” can only be used twice in one frame.
When you call the functions “slPutPolygon”, “slPutSprite”, etc., the first window is used at that point, and after that you can only call “slWindow” one more time.
(If you call the above function, the default window settings will change)

Only one window setting is active at a time. Also, when you call the function "slWindow", the priority is separated from the polygons (sprites) before it and those after it, and in this case, the latter always takes precedence.

Listing 4-8 Scope of influence of window settings

		: /* Window 1 (default) */
	slPutPolygon( object1 );
		:
	slPutPolygon( object2 );
		:
slWindow(.....); ←
		: /* Wind 2 */
	slPutPolygon( object3 );
		:
slWindow(.....); ←Error: /* Stay in window 2 */
	slPutPolygon( object4 );
		:
	slPutPolygon( object5 );
		:

• For example
  First, object1 and object2 are displayed by the default window, and then window 2 is set.
• In response to this, the default window 1 and the newly set window 2 will appear on the projection surface.
  object3 drawn in this state will be affected by the new window.
• If you run slWindow again, an error will occur because two windows are already in use, and you will not be able to set a new one.
• object4 and object5 are drawn on the projection plane under the influence of window 2.

Additional notes: SGL library functions that appeared in this chapter

In this chapter, we explained the functions in the table below.

Table 4-3 SGL library functions that appeared in this chapter

functional type	function name	parameters	function
void	slPerspective	ANGLE angp	Perspective conversion table settings
void	slRotX	ANGLE angx	Rotation of polygon data around the X axis
void	slRotY	ANGLE	Rotation of polygon data around the Y axis
void	slRotZ	ANGLE angz	Rotation of polygon data around the Z axis
void	slRotXSC	FIXED sn,FIXED cs	Rotation around the X axis by specifying Sin and Cos
void	slRotYSC	FIXED sn,FIXED cs	Rotation around the Y axis by specifying Sin and Cos
void	slRotZSC	FIXED sn,FIXED cs	Rotation around the Z axis by specifying Sin and Cos
void	slRotAX	FIXED vx,vy,cz,ANGLE a	Rotation around any axis passing through the origin (axis unit: vector)
void	slScale	FIXED sx,sy,sz	Scaling polygon data
void	slWindow	lft,top,rgt,btm,Zlimit,CNTX,CNTY	Window settings
void	slZdspLevel	level	Viewing volume display level specification