S2PLOT - New pages [en]

Function:ss2scaf

2011-08-29T05:27:02Z

Summary:

==ss2scaf==

Set the camera position, up vector, view direction and camera rotate/focus point.

==Prototype==

<code><pre>
void ss2scaf(XYZ position, XYZ up, XYZ vdir, XYZ focus, int worldcoords);
</pre></code>

==Description==

Set the camera position, up vector, view direction AND focus (rotate-about) point, all in one shot. If worldcoords > 0 then caller has given world coordinates, otherwise viewport coordinates are used. It is up to the caller to ensure a self-consistent camera position is given (orthogonal vectors).

== See Also ==
<table>
<tr><td>[[Function:ss2sc | ss2sc ]]</td><td>Set the camera position, up vector and view direction.</td></tr>
<tr><td>[[Function:ss2qc | ss2qc ]]</td><td>Query the camera position, up vector and view direction. </td></tr>
<tr><td>[[Function:ss2sca | ss2sca ]]</td><td>Set the camera aperture. </td></tr>
<tr><td>[[Function:ss2qca | ss2qca ]]</td><td>Query the camera aperture. </td></tr>
<tr><td>[[Function:ss2scs | ss2scs ]]</td><td>Set the camera speed. </td></tr>
<tr><td>[[Function:ss2qcs | ss2qcs ]]</td><td>Query the camera speed. </td></tr>
</table>

==Code Example==
<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "s2plot.h"

int main(int argc, char *argv[])
{
XYZ pos; /* Camera position */
XYZ up; /* Camera up vector */
XYZ view; /* Camera view vector */
XYZ focus;
int wc = 1; /* Use world coordinates */
int i, N = 20; /* Loop variables */
float x, y, z; /* Temporary data */

srand48((long)time(NULL)); /* Seed random numbers */

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDE",0,0,"BCDE",0,0,"BCDE",0,0); /* Draw coordinate box */

for (i=0;i<N;i++) {
x = drand48()*2.0 - 1.0; /* Random positions */
y = drand48()*2.0 - 1.0;
z = drand48()*2.0 - 1.0;
s2sci(15*drand48()+1); /* Random colour */
s2pt1(x, y, z, 1);
}

pos.x = 0.0; pos.y = 0.0; pos.z = 8.0;
up.x = 0.0; up.y = 1.0; up.z = 0.0;
view.x = 0.0; view.y = 0.0; view.z = -1.0;
focus.x = 0.0; focus.y = 0.0; focus.z = 1.0;
ns2thpoint(focus.x, focus.y, focus.z, 1,1,1, 8);

ss2scaf(pos, up, view, focus, wc); /* Set new camera position */
ss2sas(1);

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.
__NOTOC__
__NOEDITSECTION__

Function:ss2qpr

2011-08-29T05:24:40Z

Summary:

==ss2qpr==
Query point to rotate camera about.

==Prototype==

<code><pre>
void ss2qpr(XYZ *position, int worldcoords);
</pre></code>

==Description==
Query the point to rotate about camera and geometry about. Fortunately or unfortunately, this is not guaranteed to be the same as the focus point (what the camera is looking at); the meanings are mixed and need to be disentangled. For now, we allow querying of this point independent of the focus point, as it is needed for some things like GPU-based volume rendering.

== See Also ==
<table>
<tr><td>[[Function:ss2scf | ss2scf]]</td><td>Set the camera mid/focus point. </td></tr>
<tr><td>[[Function:ss2scf | ss2scf]]</td><td>Unset the camera mid/focus point - return to auto mid-point </td></tr>
</table>

==Code Example==
<code><pre>
#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "s2plot.h"

void cb(double *t, int *kc)
/* Dynamic callback function */
{
XYZ rot;
int wc = 1; /* Use world coordinates */
XYZ off = { 0.01, 0.01, 0.0 }; /* Small offset for text */

int set;
char string[255];
s2sch(0.05); /* Set the text height */
if (*kc%2 == 0) {
ss2qpr(&rot, wc); /* Query the rotation point */
sprintf(string,"Rotation about (%.2f, %.2f, %.2f)",rot.x,rot.y,rot.z);
XYZ xyz = { 0.5, 0.5, 0.5 };
ss2scf(xyz, wc); /* Set the camera focus */
} else {
ss2qcf(&set, &rot, wc); /* Query the camera focus */
sprintf(string,"Focus at (%.2f, %.2f, %.2f)",rot.x,rot.y,rot.z);
}
ds2vtb(rot, off,string,1); /* Write some dynamic billboard text */
s2lab("","","","<space> to toggle mode");
/* Display an instructional label */

}

int main(int argc, char *argv[])
{
int i; /* Loop variable */
XYZ xyz; /* Coordinate for plotting points */
COLOUR col; /* Colour of plotted points */

s2opend("/S2MONO",argc,argv); /* Query the s2plot device to use */
s2swin(-1.,1.,-1.,1.,-1.,1.); /* Set the world coordinates */
s2box("BCDE",0,0,"BCDE",0,0,"BCDE",0,0); /* Draw a coordinate box */

srand48((long)time(NULL)); /* Seed the random number generator */

for (i=0;i<1000;i++) { /* Generate and plot random points */
xyz.x = drand48()*2.0 - 1.0; /* with random colours */
xyz.y = drand48()*2.0 - 1.0;
xyz.z = drand48()*2.0 - 1.0;
col.r = drand48();
col.g = drand48();
col.b = drand48();
ns2vpoint(xyz, col);
}
ss2sas(1); /* Start the geometry auto-spinning */
cs2scb(cb); /* Install a dynamic callback */
s2show(1); /* Display the geometry */
return 0;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.
__NOTOC__
__NOEDITSECTION__

Function:ns2sevas

2011-08-29T05:22:12Z

Summary:

==ns2sevas==

==Prototype==

<code><pre>
void ns2sevas(float sx, float sy, float sz);
</pre></code>

==Description==
Provides support for explicitly setting alpha scaling values for a volume rendering object, overriding the default alpha scaling mode if axis values are > 0.0

==See Also==
<table>
<tr><td>[[Function:ns2svas | ns2svas]]</td><td>Set alpha scaling mode. </td></tr>
<tr><td>[[Function:ns2qvas | ns2qvas]]</td><td>Query alpha scaling mode. </td></tr>
<tr><td>[[Function:ns2cvr | ns2cvr ]]</td><td>Create a volume rendering object. </td></tr>
<tr><td>[[Function:ns2cvra| ns2cvra ]]</td><td>Render volume of objects. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include "s2plot.h"

/* Global variables */
int vid; /* ID for volume render object */
float tr[12]; /* Transformation matrix */
float ***volume; /* The data cube */
int nx, ny, nz; /* Data grid dimensions */

float ***initVolume(int nx, int ny, int nz)
/* Allocate memory and initialise a data cube */
{
float ***volume;
int i, j, k;

volume = (float ***)malloc(nx * sizeof(float **));
if (volume == NULL) {
fprintf(stderr,"Failed to allocate %ld bytes\n",(long)(nx*sizeof(float **)));
exit(-1);
}
for (i=0;i<nx;i++) {
volume[i] = (float **)malloc(ny * sizeof(float *));
if (volume[i] == NULL) {
fprintf(stderr,"Failed to allocate %ld bytes\n",(long)(nx*sizeof(float *)));
exit(-1);
}
for (j=0;j<ny;j++) {
volume[i][j] = (float *)malloc(nz * sizeof(float));
if (volume[i][j] == NULL) {
fprintf(stderr,"Failed to allocate %ld bytes\n",(long)(nx*sizeof(float)));
exit(-1);
}
for (k=0;k<nz;k++) {
volume[i][j][k] = 0.0; /* Initialise */
}
}
}

return volume;
}

void cb(double *t, int *kc)
/* A dynamic callback */
{
s2lab("","","","Press <space> to toggle opactiy mode for volume rendering");
float sx, sy, sz; /* Opacity scale factors */

if (*kc % 2 == 1 ) {
sx = (float)nz/(float)nx;
sy = (float)nz/(float)ny;
sz = 1.0; /* Shortest axis gets highest opacity scale */
ns2sevas(sx,sy,sz); /* Set the opacity scaling */
} else {
ns2sevas(1.,1.,1.); /* Set the opacity scaling */
}
ds2dvr(vid, 1); /* Draw the volume render object */
}

int main(int argc, char *argv[])
{
int i; /* Loop variable */
float dmin, dmax, amin, amax; /* Min/max values */
char trans; /* Transparency mode */
float x1 = -1.0, x2 = +1.0; /* Data range along axes */
float y1 = -1.0, y2 = +1.0;
float z1 = -1.0, z2 = +1.0;
int vi, vj, vk; /* Temporary variables */
float dx, dy, dz; /* Temporary variables */
COLOUR amb = {0.8, 0.8, 0.8}; /* Ambient light */

srand48((long)time(NULL)); /* Seed random numbers */

nx = 40; ny = 40; nz = 10; /* Dimensions of data cube */
volume = initVolume(nx, ny, nz); /* Allocate memory */

for (i=0;i<12;i++) { /* Set-up transfrom matrix */
tr[i] = 0.0;
}
tr[ 0] = x1; /* Mapping from data cube */
tr[ 1] = (x2-x1)/(float)(nx-1.0); /* to physical coordinates */
tr[ 4] = y1;
tr[ 6] = (y2-y1)/(float)(ny-1.0);
tr[ 8] = z1;
tr[11] = (z2-z1)/(float)(nz-1.0);

dmin = 0.0; /* Mininum data value in volume to plot */
dmax = 2.0; /* Maximum data value in volume to plot */
amin = 0.0; /* Minimum alpha channel value */
amax = 0.8; /* Maximum alpha channel value */
trans = 't'; /* Transparency type */

dx = tr[1]*0.5; /* Offsets for window - voxels are pixel */
dy = tr[6]*0.5; /* centred */
dz = tr[11]*0.5;

s2opend("/S2MONO",argc,argv); /* Open the display */
s2swin(x1-dx,x2+dx, y1-dy,y2+dy, z1-dz,z2+dz); /* Set window coords */
s2box("BCDE",0,0,"BCDE",0,0,"BCDE",0,0); /* Draw coord box */

long N = 5000;

for (i=0;i<N;i++) { /* Create N random (x,y,z) values */
vi = (int)(drand48()*(nx));
vj = (int)(drand48()*(ny));
vk = (int)(drand48()*(nz));

volume[vi][vj][vk]+=1.0-drand48()*drand48();
/* Give a value to volume */
}

s2scir(1000,2000); /* Set colour range */
s2icm("mgreen",1000,2000); /* Install colour map */
vid = ns2cvr(volume, nx, ny, nz, 0, nx-1, 0, ny-1, 0, nz-1,
tr, trans, dmin, dmax, amin, amax);
/* Create the volume render object */

cs2scb(cb); /* Install a dynamic callback */
ss2srm(SHADE_FLAT); /* Set shading type to FLAT */
ss2sl(amb, 0, NULL, NULL, 0); /* Ambient lighting only */

ss2sas(1); /* Start the cube spinning */

s2show(1); /* Open the s2plot window */

return 1;
}

</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2vf3nca

2011-08-29T03:43:42Z

Summary:

==ns2vf3nca==

3-vertex facet with coloured vertices, normals and alpha per vertex given.

==Prototype==

<code><pre>
void ns2vf3nca(XYZ *P, XYZ *N, COLOUR *col, char trans, float *alf);
</pre></code>

==Description==

Complete control of 3-vertex facets is achieved with this function. Draws a 3-vertex facet with coloured vertices, with normals, and per vertex alpha transparency value for the facet. The vertices are given by the array P, normals are in the array N, and the RGB colours for vertices are in col.
Transparency parameter trans is one of 'o' (opaque), 't' (addition blend - never gets dimmer) or 's' (standard blend, can get dimmer), and the alpha values in the range [0,1] are stored in array alf.

== See Also ==
<table>
<tr><td>[[Function:ns2vf3 | ns2vf3 ]]</td><td>3-vertex facet with single colour and automatic normals. </td></tr>
<tr><td>[[Function:ns2vf3n | ns2vf3n ]]</td><td>3-vertex facet with single colour and normals given. </td></tr>
<tr><td>[[Function:ns2vf3c | ns2vf3c ]]</td><td>3-vertex facet with coloured vertices and autmoatic normals. </td></tr>
<tr><td>[[Function:ns2vf3a | ns2vf3a ]]</td><td>3-vertex facet with transparency </td></tr>
<tr><td>[[Function:struct_COLOUR | struct_COLOUR ]]</td><td>Data structure for (r,g,b) colour indices. </td></tr>
<tr><td>[[Function:struct_XYZ | struct_XYZ ]]</td><td>Data structure for (x,y,z) coordinates. </td></tr>
</table>

==Code Example==
<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "s2plot.h"

int main(int argc, char *argv[])
{
XYZ vertex[3]; /* 3 vertices */
XYZ normal[3]; /* 3 vertices */
float alpha[3]; /* 3 vertices */
COLOUR col[3]; /* 3 vertices */
char trans = 't'; /* Transparency type */
int i;

srand48((long)time(NULL)); /* Seed random numbers */
s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

for (i=0;i<3;i++) {
vertex[i].x = drand48()*2.0 - 1.0; /* Random corners to facet */
vertex[i].y = drand48()*2.0 - 1.0;
vertex[i].z = drand48()*2.0 - 1.0;
normal[i].x = drand48()*2.0 - 1.0; /* Random normal for facet */
normal[i].y = drand48()*2.0 - 1.0;
normal[i].z = drand48()*2.0 - 1.0;
col[i].r = drand48(); /* Random colour for vertex */
col[i].g = drand48();
col[i].b = drand48();
}
alpha[0] = 0.0; /* Set alpha channels for each */
alpha[1] = 0.5; /* vertex */
alpha[2] = 1.0;
ns2vf3nca(vertex, normal, col, trans, alpha);
/* Draw polygon with defined normals, vertex colours */
/* and vertex transparencies */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>
[[S2PLOT:Function List | Back]] to S2PLOT function list.
__NOTOC__
__NOEDITSECTION__

Function:ns2vf3na

2011-08-29T03:35:34Z

Summary:

==ns2vf3na==

Transparent 3-vertex facet with coloured vertices, normals and alpha given.

==Prototype==

<code><pre>
void ns2vf3na(XYZ *P, XYZ *N, COLOUR col, char trans, float alpha);
</pre></code>

==Description==

Function for drawing a 3-vertex facet with coloured vertices, with normals, and a single alpha transparency value for the facet. The vertices are given by the array P, normals are in the array N, and the RGB colours for vertices are in col.
Transparency parameter trans is one of 'o' (opaque), 't' (addition blend - never gets dimmer) or 's' (standard blend, can get dimmer), and the alpha value is in the range [0,1].

== See Also ==
<table>
<tr><td>[[Function:ns2vf3 | ns2vf3 ]]</td><td>3-vertex facet with single colour and automatic normals. </td></tr>
<tr><td>[[Function:ns2vf3n | ns2vf3n ]]</td><td>3-vertex facet with single colour and normals given. </td></tr>
<tr><td>[[Function:ns2vf3c | ns2vf3c ]]</td><td>3-vertex facet with coloured vertices and autmoatic normals. </td></tr>
<tr><td>[[Function:ns2vf3a | ns2vf3a ]]</td><td>3-vertex facet with transparency </td></tr>
<tr><td>[[Function:struct_COLOUR | struct_COLOUR ]]</td><td>Data structure for (r,g,b) colour indices. </td></tr>
<tr><td>[[Function:struct_XYZ | struct_XYZ ]]</td><td>Data structure for (x,y,z) coordinates. </td></tr>
</table>

==Code Example==
<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "s2plot.h"

int main(int argc, char *argv[])
{
XYZ vertex[3]; /* 3 vertices */
XYZ normal[3]; /* 3 vertices */
COLOUR col; /* Polygon colour */
char trans = 't'; /* Transparency type */
float alpha = 0.7; /* Alpha channel value */
int i;

srand48((long)time(NULL)); /* Seed random numbers */
s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

for (i=0;i<3;i++) {
vertex[i].x = drand48()*2.0 - 1.0; /* Random corners to facet */
vertex[i].y = drand48()*2.0 - 1.0;
vertex[i].z = drand48()*2.0 - 1.0;
normal[i].x = drand48()*2.0 - 1.0; /* Random normal for facet */
normal[i].y = drand48()*2.0 - 1.0;
normal[i].z = drand48()*2.0 - 1.0;
}
col.r = drand48(); /* Random colour for polygon*/
col.g = drand48();
col.b = drand48();
ns2vf3na(vertex, normal, col, trans, alpha);
/* Draw polygon with specified vertices, normals, */
/* colour and single alpha channel */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>
[[S2PLOT:Function List | Back]] to S2PLOT function list.
__NOTOC__
__NOEDITSECTION__

Function:s2funuva

2011-08-29T02:24:15Z

Summary:

==s2funuva==

Plot a parametric function (generally a surface) defined by functions fx(u,v), fy(u,v) and fz(u,v) with transparency.

==Prototype==

<code><pre>
void s2funuva(float(*fx)(float*, float*), float(*fy)(float*, float*), float(*fz)(float*, float*),
float(*fcol)(float*,float*), char trans, float(*falpha)(float*, float*),
float umin, float umax, int uDIV, float vmin, float vmax, int vDIV);
</pre></code>

==Description==

Plot the parametric function (generally a surface) defined by { (fx(u,v), fy(u,v), fz(u,v) }, coloured by fcol(u,v) with fcol required to fall in the range [0,1]. fcol is then mapped to the current colormap index range (set with s2scir). Transparency is applied to the surface with falpha(u,v), defining the opacity in the range [0,1]. The range of u and v values are specified by umin,umax and vmin, vmax, and the number of divisions by uDIV and vDIV.

For a constant opacity, implement falpha(u,v){return const_value;}.

== See Also ==
<table>
<tr><td>[[Function:s2scir | s2scir ]]</td><td>Set the range of colour indices used for shading. </td></tr>
<tr><td>[[Function:s2funuv| s2funuv ]]</td><td>Plot a parametric function. </td></tr>
</table>

==Code Example==
<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "s2plot.h"

#define LIMIT 0.7
#define pi 3.14159265359

/* amplitude, number of twists, major radius, minor radius */
#define AMP 0.4 /* Amplitude */
#define NTW 1.5 /* Number of twists */
#define R1 2.0 /* Major radius */
#define R2 0.5 /* Minor radius */

/* Parametric functions for surface */
inline float tkx(float *u, float *v) {
return R2 * cos(*v) * cos(*u) + R1 * cos(*u) * (1. + AMP * cos(*u * NTW));
}
inline float tky(float *u, float *v) {
return R2 * sin(*v) + AMP * sin(*u * NTW);
}
inline float tkz(float *u, float *v) {
return R2 * cos(*v) * sin(*u) + R1 * sin(*u) * (1. + AMP * cos(*u * NTW));
}
inline float fcol(float *u, float *v) {
return 0.5 + sin(0.5 * *u) * AMP * sin(*v);
}
inline float falpha(float *u, float *v) {
if ((*v) < pi) return 0.0;
else return 1.0;
}

int main(int argc, char *argv[])
{

float x1 = -LIMIT, x2 = LIMIT; /* x world coord range */
float y1 = -LIMIT, y2 = LIMIT; /* y world coord range */
float z1 = -LIMIT, z2 = LIMIT; /* z world coord range */
char trans = 't'; /* Transparency type */

s2opend("/?",argc, argv); /* Open the display */
s2swin(x1, x2, y1, y2, z1, z2); /* Set the window coordinates */

s2icm("rainbow", 100, 500); /* Install colour map */
s2scir(100, 500); /* Set colour range */

s2funuva(tkx, tky, tkz, fcol, trans, falpha, 0., 4.*pi, 320, 0., 2.*pi, 90);
/* call the parametric surface function */

s2show(1); /* Open the s2plot window */

return 1;

}
</pre></code>
[[S2PLOT:Function List | Back]] to S2PLOT function list.
__NOTOC__
__NOEDITSECTION__

Function:s2qwc

2011-08-29T02:13:34Z

Summary:

==s2qwc==
Query the window clipping mode.

==Prototype==

<code><pre>
int s2qwc(void);
</pre></code>

==Description==
Query whether clipping is being applied to geometry. When enabled, clipping means points not within the world coordinate bounds as defined by the most recent call to s2swin, will not be drawn. The initial implementation applies to points only, future work may apply the clipping to lines and facets as well. Enable/disable/toggle (1,0,-1) clipping.

== See Also ==
<table>
<tr><td>[[Function:s2twc | s2twc]]</td><td>Set the window clipping mode.</td><td> </td></tr>
</table>

==Code Example==
<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "s2plot.h"

void cb(double *t, int *kc)
{
int N = 100; /* Number of points */
static int flag = -1; /* Flag for initialisation */
static XYZ xyz[100]; /* Array of point positions */
static COLOUR col[100]; /* Array of colours */
int i; /* Loop variable */

if (flag < 0) { /* First time through? */
for (i=0;i<N;i++) {
xyz[i].x = drand48()*2.0 - 1.0; /* Random data positions */
xyz[i].y = drand48()*2.0 - 1.0;
xyz[i].z = drand48()*2.0 - 1.0;
col[i].r = drand48(); /* Random data colours */
col[i].g = drand48();
col[i].b = drand48();
}
flag = 1; /* Set the flag */
}

s2swin(-0.8,0.8,-0.8,0.8,-0.8,0.8); /* Set new plotting window */

for (i=0;i<N;i++) {
ns2vthpoint(xyz[i], col[i], 3); /* Draw the point */
}

if (*kc % 2 == 1) /* Check for keyboard press */
s2twc(1); /* Turn on clipping */
else
s2twc(0); /* Turn off clipping */

int wc = s2qwc(); /* Query clipping state */
char text[32];
sprintf(text, "Clipping state: %d\n",wc); /* Prepare a text string */
s2textxy(0.0,0.0,0.0, text); /* Display text string */

s2lab("","","","Press <space> to toggle clipping state");
}

int main(int argc, char *argv[])
{

srand48((long)time(NULL)); /* Seed random numbers */

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

cs2scb(cb); /* Install a dynamic callback */

s2show(1); /* Open the s2plot window */

return 1;
}

</pre></code>
[[S2PLOT:Function List | Back]] to S2PLOT function list.
__NOTOC__
__NOEDITSECTION__

Function:s2twc

2011-08-29T02:12:06Z

Summary:

==s2twc==
Set the window clipping mode.

==Prototype==

<code><pre>
void s2twc(int enabledisable);
</pre></code>

==Description==
Set whether clipping is being applied to geometry. When enabled, clipping means points not within the world coordinate bounds as defined by the most recent call to s2swin, will not be drawn. The initial implementation applies to points only, future work may apply the clipping to lines and facets as well. Enable/disable/toggle (1,0,-1) clipping.

== See Also ==
<table>
<tr><td>[[Function:s2qwc | s2qwc]]</td><td>Query the window clipping mode.</td><td> </td></tr>
</table>

==Code Example==
<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "s2plot.h"

void cb(double *t, int *kc)
{
int N = 100; /* Number of points */
static int flag = -1; /* Flag for initialisation */
static XYZ xyz[100]; /* Array of point positions */
static COLOUR col[100]; /* Array of colours */
int i; /* Loop variable */

if (flag < 0) { /* First time through? */
for (i=0;i<N;i++) {
xyz[i].x = drand48()*2.0 - 1.0; /* Random data positions */
xyz[i].y = drand48()*2.0 - 1.0;
xyz[i].z = drand48()*2.0 - 1.0;
col[i].r = drand48(); /* Random data colours */
col[i].g = drand48();
col[i].b = drand48();
}
flag = 1; /* Set the flag */
}

s2swin(-0.8,0.8,-0.8,0.8,-0.8,0.8); /* Set new plotting window */

for (i=0;i<N;i++) {
ns2vthpoint(xyz[i], col[i], 3); /* Draw the point */
}

if (*kc % 2 == 1) /* Check for keyboard press */
s2twc(1); /* Turn on clipping */
else
s2twc(0); /* Turn off clipping */

int wc = s2qwc(); /* Query clipping state */
char text[32];
sprintf(text, "Clipping state: %d\n",wc); /* Prepare a text string */
s2textxy(0.0,0.0,0.0, text); /* Display text string */

s2lab("","","","Press <space> to toggle clipping state");
}

int main(int argc, char *argv[])
{

srand48((long)time(NULL)); /* Seed random numbers */

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

cs2scb(cb); /* Install a dynamic callback */

s2show(1); /* Open the s2plot window */

return 1;
}

</pre></code>
[[S2PLOT:Function List | Back]] to S2PLOT function list.
__NOTOC__
__NOEDITSECTION__

Function:ss2ltt

2009-01-27T03:26:32Z

Summary:

==ss2ltt==

Create a texture with LATEX commands.

==Prototype==

<code><pre>
unsigned int ss2ltt(char *latexcmd, float *aspect);
</pre></code>

==Description==

Create a texture with LaTeX commands contained in the string latexcmd. The return value is the texture handle (as used by eg. ns2vf4xt etc). The x:y aspect ratio of the texture map is returned in aspect.

This function assumes that LaTeX is installed on your system in the location indicated by the environment variable S2PLOT_LATEXBIN.

== See Also ==
<table>
<tr><td>[[Function:ss2lt | ss2lt ]]</td><td>Load a texture for future (generally repeated) use. </td></tr>
<tr><td>[[Function:ss2ftt | ss2ftt ]]</td><td>Use a named freetype font to create a texture map.</td></tr>
</table>

==Code Example==
<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

int main(int argc, char *argv[])
{
char *latexcmd = "$f(x) = \\Sigma^{\\infty}_{i=0} a_i \\sin(2\\pi x)$";
XYZ pos[4]; /* Vertices for texture */
COLOUR col = { 1.0, 1.0, 1.0 }; /* Polygon colour */
float aspect; /* Aspect ratio */
unsigned int id; /* Texture id */

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

id = ss2ltt(latexcmd, &aspect); /* Create latex texture */
/* Must have S2PLOT_LATEXBIN environment variable correctly set */

aspect = 1.0/aspect;

pos[0].x = -1.0; pos[0].y = +aspect; pos[0].z = 0.0;
pos[1].x = +1.0; pos[1].y = +aspect; pos[1].z = 0.0;
pos[2].x = +1.0; pos[2].y = -aspect; pos[2].z = 0.0;
pos[3].x = -1.0; pos[3].y = -aspect; pos[3].z = 0.0;

ns2vf4x(pos, col, id, 1.0, 'o'); /* Draw the texture */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>
[[S2PLOT:Function List | Back]] to S2PLOT function list.
__NOTOC__
__NOEDITSECTION__

Function:ss2ftt

2009-01-27T03:24:24Z

Summary:

==ss2ftt==
Use a named freetype font to create a texture map.

==Prototype==

<code><pre>
unsigned int ss2ftt(char *fontfilename, char *text, int fontsizepx, int border);
</pre></code>

==Description==
Load a named freetype font, where fontfilename includes the full pathname to the font, to generate a texture map from the input text. Argument fontsizepx controls the font size, and an optional border can be drawn around the text using border > 0.

This function is only available if the [[S2PLOT:Environment_Variables | S2FREETYPE]] environment variable has been set to 'yes'.

== See Also ==
<table>
<tr><td>[[Function:ss2lt | ss2lt ]]</td><td>Load a texture for future (generally repeated) use. </td></tr>
<tr><td>[[Function:ss2ltt | ss2ltt ]]</td><td>Create a texture with LATEX commands.. </td></tr>
</table>

==Code Example==
<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

unsigned int tid;

void cb(double *t, int *kc)
{
XYZ xyz = {0.0, 0.3, 0.4}; /* Location */
float isize = 0.02; /* Texture scale */
XYZ str = { 0.0, 0.0, 0.0}; /* No stretch */
COLOUR col = { 1.0, 1.0, 0.0 }; /* Yellow */
float alpha = 0.9; /* Alpha channel */
char trans = 's'; /* Transparency */

ds2vbb(xyz, str, isize, col, tid, alpha, trans); /* Draw the billboard */
}

int main(int argc, char *argv[])
{
s2opend("/?",argc,argv); /* Open the display */
s2svp(-1.0,1.0, -1.0,1.0, -1.0,1.0); /* Set the viewport coords */
s2swin(-1.0,1.0, -1.0,1.0, -1.0,1.0); /* Set the window coordinates */
s2box("BCDE",0,0,"BCDE",0,0,"BCDE",0,0); /* Draw a bounding box */

char font[64]; /* Allocate font name string */

sprintf(font,"/Library/Fonts/Arial Black"); /* Path to font */
/* NOTE: This depends on your local system config */

tid = ss2ftt(font,"s2plot",32,4); /* Create the texture */

cs2scb(&cb); /* Install a callback */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>
[[S2PLOT:Function List | Back]] to S2PLOT function list.
__NOTOC__
__NOEDITSECTION__

Function:cs2srcb

2009-01-07T00:28:03Z

Summary:

==cs2srcb==
Register when remote control data is received.
==Prototype==
<code><pre>
void cs2srcb(void *remcb);
</pre></code>

==Description==
Register function that is called when remote control data comes in. This function can consume the event (by returning 1) to prevent further (built-in) handling by S2PLOT.

==See Also==
<table>
<tr><td>[[Function:cs2socb |cs2socb]]</td><td>Register function that will draw direct OpenGL graphics when called.</td></tr>
<tr><td>[[Function:s2ldev |s2ldev]]</td><td>List the available S2PLOT devices on stdout.</td></tr>
<tr><td>[[Function:s2disp |s2disp]]</td><td>Draw the scene, but return control when a timeout occurs or when shift-ENTER is pressed.</td></tr>
<tr><td>[[Function:s2show | s2show ]]</td><td>Draw the scene and enter interactive mode if interactive is non-zero. </td></tr>
</table>

==Sample Code==

Some additional steps are required to get the remote callback to function. After you have compiled the sample code, you will need to follow these steps:

1. In the terminal/shell you are planning to run the executable in (cs2srcb), type
<code><pre>
setenv S2PLOT_REMOTEPORT 3333
</pre></code>
Note that you can use another port number instead of 3333 if required.

2. Run the code

3. In another terminal/shell type the following:
<code><pre>
telnet localhost 3333
S2 setcolor 0.9,0.1,0.5
</pre></code>

4. The polygon/billboard should now change colour.

5. Quitting the executable (shift-Q) should close the terminal session.

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include "s2plot.h"

unsigned int tid;

float _bb_r, _bb_g, _bb_b;

int remote_cb(char *data);
void cb(double *t, int *kc);

int main(int argc, char *argv[])
{
int width = 16, height = 16; /* Dimensions of texture */
int i, j; /* Loop variables */
int idx; /* Index into texture array */
unsigned char *tex; /* Array of texture values */

srand48((long)time(NULL)); /* Seed random numbers */

s2opend("/?",argc,argv); /* Open the display */
s2svp(-1.0,1.0, -1.0,1.0, -1.0,1.0); /* Set the viewport coords */
s2swin(-1.0,1.0, -1.0,1.0, -1.0,1.0); /* Set the window coordinates */
s2box("BCDE",0,0,"BCDE",0,0,"BCDE",0,0); /* Draw a bounding box */

tid = ss2ct(width, height); /* Create a new texture */
tex = ss2gt(tid, &width, &height); /* Get the texture */

for (j=0;j<height;j++) {
for (i=0;i<width;i++) {
idx = (j*width + i) * 4; /* Stored as (r,g,b,alpha) */
tex[idx ] = 255; /* solid red */
tex[idx+1] = 255; /* Green */
tex[idx+2] = 255; /* Blue */
tex[idx+3] = 127 * drand48()+128; /* Random transparency */
}
}
ss2pt(tid); /* Push texture for usage */

_bb_g = 0.7;
_bb_b = 0.9;

cs2scb(&cb); /* Install a callback */
cs2srcb(&remote_cb); /* Install remote callback */

s2show(1); /* Open the s2plot window */

return 1;
}

void cb(double *t, int *kc)
{
float x = 0.0, y = 0.3, z = 0.4; /* Location */
float isize = 0.02; /* Texture scale */
float str_x = 0.0, str_y = 0.0, str_z = 0.0; /* No stretch */
float alpha = 0.9; /* Alpha channel */
char trans = 't'; /* Transparency */

ds2bb(x,y,z, str_x,str_y,str_z, isize, _bb_r, _bb_g, _bb_b, tid, alpha, trans);
/* Draw the billboard */
}

int remote_cb(char *data) {
// this remote callback will receive strings coming in on
// the S2PLOT_REMOTEPORT port.

char *contype, *ctype, *cargs;

contype = strtok(data, " ");

// for this demo, we will only parse commands preceded by "S2"
if (!contype || strcmp(contype, "S2")) {
// return 0 to indicate we have not "consumed" this event
fprintf(stderr, "remote_cb: no valid command prefix\n");
return 0;
}

ctype = strtok(NULL, " ");
if (!ctype) {
fprintf(stderr, "remote_cb: no command present\n");
return 0;
}

int consumed = 0;

// the only command we accept is "setcolor" to set the
// billboard color
if (!strcmp(ctype, "setcolor")) {
cargs = strtok(NULL, " ");
if (!cargs) {
fprintf(stderr, "remote_cb: no argument for setcolor present\n");
return 0;
}
float vr, vg, vb;
sscanf(cargs, "%f,%f,%f", &vr, &vg, &vb);

if ((vr >= 0.) && (vr <= 1.) &&
(vg >= 0.) && (vg <= 1.) &&
(vb >= 0.) && (vb <= 1.)) {
_bb_r = vr;
_bb_g = vg;
_bb_b = vb;
}

consumed = 1;
} else {
fprintf(stderr, "remote_cb: unknown command %s\n", ctype);
}

return consumed;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ds2bbset

2009-01-06T22:28:59Z

Summary:

==ds2bbset==
Draw a set of billboards.

==Prototype==

<code><pre>
void ds2bbset(float *verts, float *cols, float size,
unsigned int texid, char trans, int n);
</pre></code>

==Description==
Draw a set of billboards.

==See Also==
<table>
<tr><td>[[Function:ds2vbbp | ds2vbbp]]</td><td>Billboard with aspect ratio - vector input.</td></tr>
<tr><td>[[Function:ds2vbbpr | ds2vbbpr ]]</td><td>Billboard with aspect ratio, offset in screen coords, and rotation of texture - vector input. </td></tr>
<tr><td>[[Function:ds2bb | ds2bb ]]</td><td>Draw a (dynamic) billboard: a textured facet that always faces the camera. </td></tr>
<tr><td>[[Function:ds2vbb | ds2vbb ]]</td><td>Draw a (dynamic) billboard: a textured facet that always faces the camera - vector input </td></tr>
<tr><td>[[Function:ds2vbbr | ds2vbbr ]]</td><td>Draw a (dynamic) billboard texture with specified rotation.</td></tr>
<tr><td>[[Function:ds2tb | ds2tb ]]</td><td>Draw text that always faces the camera </td></tr>
<tr><td>[[Function:ds2vtb | ds2vtb ]]</td><td>Draw text that always faces the camera - vector input </td></tr>
</table>

==Code Example==

<code><pre>
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ds2vbbpr

2009-01-06T22:28:43Z

Summary:

==ds2vbbpr==
Billboard with aspect ratio, offset in screen coords, and rotation of texture - vector input.

==Prototype==
<code><pre>
void ds2vbbpr(XYZ iP, XYZ offset, float aspect, float isize,
float ipangle, COLOUR iC, unsigned int itexid, float alpha, char trans);
</pre></code>

==Description==
Billboard with aspect ratio, offset in screen coords, and rotation of the texture about the view direction.

==See Also==
<table>
<tr><td>[[Function:ds2vbbp | ds2vbbp]]</td><td>Billboard with aspect ratio - vector input.</td></tr>
<tr><td>[[Function:ds2bb | ds2bb ]]</td><td>Draw a (dynamic) billboard: a textured facet that always faces the camera. </td></tr>
<tr><td>[[Function:ds2vbb | ds2vbb ]]</td><td>Draw a (dynamic) billboard: a textured facet that always faces the camera - vector input </td></tr>
<tr><td>[[Function:ds2vbbr | ds2vbbr ]]</td><td>Draw a (dynamic) billboard texture with specified rotation.</td></tr>
<tr><td>[[Function:ds2tb | ds2tb ]]</td><td>Draw text that always faces the camera </td></tr>
<tr><td>[[Function:ds2vtb | ds2vtb ]]</td><td>Draw text that always faces the camera - vector input </td></tr>
<tr><td>[[Function:ss2ct | ss2ct ]]</td><td>Create a texture with specified width and height </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "s2plot.h"

unsigned int tid;

void cb(double *t, int *kc)
{
XYZ xyz = {0.0, 0.3, 0.4}; /* Location */
float isize = 0.05; /* Texture scale */
XYZ offset = { 0.2, 0.1, 0.0}; /* Texture offset to reference point */
float aspect = 2.2; /* Aspect ratio */
COLOUR col = { 1.0, 1.0, 0.0 }; /* Yellow */
float alpha = 0.9; /* Alpha channel */
char trans = 's'; /* Transparency */
float pangle = 45.0;

ds2vbbpr(xyz, offset, aspect, isize, pangle, col, tid, alpha, trans);

/* Billboard with aspect ratio and offset */
ns2vthpoint(xyz, col, 3); /* Plot texture reference point */

}

int main(int argc, char *argv[])
{
int width = 16, height = 16; /* Dimensions of texture */
int i, j; /* Loop variables */
int idx; /* Index into texture array */
unsigned char *tex; /* Array of texture values */

srand48((long)time(NULL)); /* Seed random numbers */
s2opend("/?",argc,argv); /* Open the display */
s2svp(-1.0,1.0, -1.0,1.0, -1.0,1.0); /* Set the viewport coords */
s2swin(-1.0,1.0, -1.0,1.0, -1.0,1.0); /* Set the window coordinates */
s2box("BCDE",0,0,"BCDE",0,0,"BCDE",0,0); /* Draw a bounding box */

tid = ss2ct(width, height); /* Create a new texture */
tex = ss2gt(tid, &width, &height); /* Get the texture */

for (j=0;j<height;j++) {
for (i=0;i<width;i++) {
idx = (j*width + i) * 4; /* Stored as (r,g,b,alpha) */
tex[idx ] = 127*drand48()+128; /* Randomish red */
tex[idx+1] = 0; /* Green */
tex[idx+2] = 0; /* Blue */
/* Do nothing to alpha */
}
}
ss2pt(tid); /* Push texture for usage */

cs2scb(&cb); /* Install a callback */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2vscube

2009-01-06T22:28:25Z

Summary:

==ns2vscube==
Draw a solid cube - vector input.

==Prototype==

<code><pre>
void ns2vscube(XYZ P1, XYZ P2, COLOUR col, float alpha);
</pre></code>

==Description==
Draw a solid cube with filled but transparent faces.

==See Also==
<table>
<tr><td>[[Function:ns2scube | ns2scube ]]</td><td>Draw a solid cube.</td></tr>
<tr><td>[[Function:s2wcube |s2wscube ]]</td><td>Draw a wireframe cube.</td></tr>
<tr><td>[[Function:ns2thwcube | ns2thwcube ]]</td><td>Draw a wireframe cube. </td></tr>
<tr><td>[[Function:ns2vthwcube | ns2vthwcube ]]</td><td>Draw a wireframe cube - vector input. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

int main(int argc, char *argv[])
{
char xopt[] = "BCDETMNOPQ";
char yopt[] = "BCDETMNOPQ";
char zopt[] = "BCDETMNOPQ";

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box(xopt, 0,0, yopt, 0,0, zopt, 0,0); /* Draw the coordinate box */
s2lab("X-axis","Y-axis","Z-axis","Plot"); /* Write some labels */

XYZ xyz1 = { -0.8, -0.8, -0.8 }; /* Box coordinate */
XYZ xyz2 = { +0.8, +0.8, +0.8 }; /* Box coordinate */
COLOUR col = { 1.0, 0.3, 0.2 }; /* RGB colours */

float alpha = 0.4; /* Alpha channel transparency */

ns2vscube(xyz1, xyz2, col, alpha);

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2qvas

2009-01-06T22:28:11Z

Summary:

==ns2qvas==
Query alpha scaling mode.

==Prototype==

<code><pre>
int ns2qvas(void);
</pre></code>

==Description==
Query alpha scaling mode for volume rendering, and normal scaling mode for isosurfaces: 0 => none, 1 => scale by volume dimensions, 2 => scale by viewport dimensions.

==See Also==
<table>
<tr><td>[[Function:ns2svas | ns2svas]]</td><td>Set alpha scaling mode. </td></tr>
<tr><td>[[Function:ns2sevas | ns2sevas]]</td><td>Explicitly set alpha scaling values. </td></tr>
<tr><td>[[Function:ns2cvr | ns2cvr ]]</td><td>Create a volume rendering object. </td></tr>
<tr><td>[[Function:ns2cvra| ns2cvra ]]</td><td>Render volume of objects. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include "s2plot.h"

/* Global variables */
int vid; /* ID for volume render object */
float tr[12]; /* Transformation matrix */
float ***volume; /* The data cube */
int nx, ny, nz; /* Data grid dimensions */

float ***initVolume(int nx, int ny, int nz)
/* Allocate memory and initialise a data cube */
{
float ***volume;
int i, j, k;

volume = (float ***)malloc(nx * sizeof(float **));
if (volume == NULL) {
fprintf(stderr,"Failed to allocate %ld bytes\n",(long)(nx*sizeof(float **)));
exit(-1);
}
for (i=0;i<nx;i++) {
volume[i] = (float **)malloc(ny * sizeof(float *));
if (volume[i] == NULL) {
fprintf(stderr,"Failed to allocate %ld bytes\n",(long)(nx*sizeof(float *)));
exit(-1);
}
for (j=0;j<ny;j++) {
volume[i][j] = (float *)malloc(nz * sizeof(float));
if (volume[i][j] == NULL) {
fprintf(stderr,"Failed to allocate %ld bytes\n",(long)(nx*sizeof(float)));
exit(-1);
}
for (k=0;k<nz;k++) {
volume[i][j][k] = 0.0; /* Initialise */
}
}
}

return volume;
}

void cb(double *t, int *kc)
/* A dynamic callback */
{
ns2svas(*kc%3); /* Set the alpha scaling mode */
int qvas = ns2qvas(); /* Query the alpha scaling mode */
char string[255];
sprintf(string,"Alpha scaling mode: %d. Press <space> to toggle mode",
qvas);
s2lab("","","",string);

ds2dvr(vid, 1); /* Draw the volume render object */
}

int main(int argc, char *argv[])
{
int i; /* Loop variable */
float dmin, dmax, amin, amax; /* Min/max values */
char trans; /* Transparency mode */
float x1 = -1.0, x2 = +1.0; /* Data range along axes */
float y1 = -1.0, y2 = +1.0;
float z1 = -1.0, z2 = +1.0;
int vi, vj, vk; /* Temporary variables */
float dx, dy, dz; /* Temporary variables */
COLOUR amb = {0.8, 0.8, 0.8}; /* Ambient light */

srand48((long)time(NULL)); /* Seed random numbers */

nx = 40; ny = 40; nz = 10; /* Dimensions of data cube */
volume = initVolume(nx, ny, nz); /* Allocate memory */

for (i=0;i<12;i++) { /* Set-up transfrom matrix */
tr[i] = 0.0;
}
tr[ 0] = x1; /* Mapping from data cube */
tr[ 1] = (x2-x1)/(float)(nx-1.0); /* to physical coordinates */
tr[ 4] = y1;
tr[ 6] = (y2-y1)/(float)(ny-1.0);
tr[ 8] = z1;
tr[11] = (z2-z1)/(float)(nz-1.0);

dmin = 0.0; /* Mininum data value in volume to plot */
dmax = 2.0; /* Maximum data value in volume to plot */
amin = 0.0; /* Minimum alpha channel value */
amax = 0.8; /* Maximum alpha channel value */
trans = 't'; /* Transparency type */

dx = tr[1]*0.5; /* Offsets for window - voxels are pixel */
dy = tr[6]*0.5; /* centred */
dz = tr[11]*0.5;

s2opend("/S2MONO",argc,argv); /* Open the display */
s2swin(x1-dx,x2+dx, y1-dy,y2+dy, z1-dz,z2+dz); /* Set window coords */
s2svp(-1,1,-1.5,1.5,-0.25,0.25);
s2box("BCDE",0,0,"BCDE",0,0,"BCDE",0,0); /* Draw coord box */

long N = 5000;

for (i=0;i<N;i++) { /* Create N random (x,y,z) values */
vi = (int)(drand48()*(nx));
vj = (int)(drand48()*(ny));
vk = (int)(drand48()*(nz));

volume[vi][vj][vk]+=1.0-drand48()*drand48();
/* Give a value to volume */
}

s2scir(1000,2000); /* Set colour range */
s2icm("mgreen",1000,2000); /* Install colour map */
vid = ns2cvr(volume, nx, ny, nz, 0, nx-1, 0, ny-1, 0, nz-1,
tr, trans, dmin, dmax, amin, amax);
/* Create the volume render object */

cs2scb(cb); /* Install a dynamic callback */

ss2srm(SHADE_FLAT); /* Set shading type to FLAT */
ss2sl(amb, 0, NULL, NULL, 0); /* Ambient lighting only */

ss2sas(1); /* Start the cube spinning */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2svas

2009-01-06T22:27:56Z

Summary:

==ns2svas==
Set alpha scaling mode.

==Prototype==

<code><pre>
void ns2svas(int mode);
</pre></code>

==Description==
Set alpha scaling mode for volume rendering, and normal scaling mode for isosurfaces: 0 => none, 1 => scale by volume dimensions, 2 => scale by viewport dimensions.

==See Also==
<table>
<tr><td>[[Function:ns2cvr | ns2cvr ]]</td><td>Create a volume rendering object. </td></tr>
<tr><td>[[Function:ns2cvra| ns2cvra ]]</td><td>Render volume of objects. </td></tr>
<tr><td>[[Function:ns2qvas | ns2qvas]]</td><td>Query alpha scaling mode. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include "s2plot.h"

/* Global variables */
int vid; /* ID for volume render object */
float tr[12]; /* Transformation matrix */
float ***volume; /* The data cube */
int nx, ny, nz; /* Data grid dimensions */

float ***initVolume(int nx, int ny, int nz)
/* Allocate memory and initialise a data cube */
{
float ***volume;
int i, j, k;

volume = (float ***)malloc(nx * sizeof(float **));
if (volume == NULL) {
fprintf(stderr,"Failed to allocate %ld bytes\n",(long)(nx*sizeof(float **)));
exit(-1);
}
for (i=0;i<nx;i++) {
volume[i] = (float **)malloc(ny * sizeof(float *));
if (volume[i] == NULL) {
fprintf(stderr,"Failed to allocate %ld bytes\n",(long)(nx*sizeof(float *)));
exit(-1);
}
for (j=0;j<ny;j++) {
volume[i][j] = (float *)malloc(nz * sizeof(float));
if (volume[i][j] == NULL) {
fprintf(stderr,"Failed to allocate %ld bytes\n",(long)(nx*sizeof(float)));
exit(-1);
}
for (k=0;k<nz;k++) {
volume[i][j][k] = 0.0; /* Initialise */
}
}
}

return volume;
}

void cb(double *t, int *kc)
/* A dynamic callback */
{
ns2svas(*kc%3); /* Set the alpha scaling mode */
int qvas = ns2qvas(); /* Query the alpha scaling mode */
char string[255];
sprintf(string,"Alpha scaling mode: %d. Press <space> to toggle mode",
qvas);
s2lab("","","",string);

ds2dvr(vid, 1); /* Draw the volume render object */
}

int main(int argc, char *argv[])
{
int i; /* Loop variable */
float dmin, dmax, amin, amax; /* Min/max values */
char trans; /* Transparency mode */
float x1 = -1.0, x2 = +1.0; /* Data range along axes */
float y1 = -1.0, y2 = +1.0;
float z1 = -1.0, z2 = +1.0;
int vi, vj, vk; /* Temporary variables */
float dx, dy, dz; /* Temporary variables */
COLOUR amb = {0.8, 0.8, 0.8}; /* Ambient light */

srand48((long)time(NULL)); /* Seed random numbers */

nx = 40; ny = 40; nz = 10; /* Dimensions of data cube */
volume = initVolume(nx, ny, nz); /* Allocate memory */

for (i=0;i<12;i++) { /* Set-up transfrom matrix */
tr[i] = 0.0;
}
tr[ 0] = x1; /* Mapping from data cube */
tr[ 1] = (x2-x1)/(float)(nx-1.0); /* to physical coordinates */
tr[ 4] = y1;
tr[ 6] = (y2-y1)/(float)(ny-1.0);
tr[ 8] = z1;
tr[11] = (z2-z1)/(float)(nz-1.0);

dmin = 0.0; /* Mininum data value in volume to plot */
dmax = 2.0; /* Maximum data value in volume to plot */
amin = 0.0; /* Minimum alpha channel value */
amax = 0.8; /* Maximum alpha channel value */
trans = 't'; /* Transparency type */

dx = tr[1]*0.5; /* Offsets for window - voxels are pixel */
dy = tr[6]*0.5; /* centred */
dz = tr[11]*0.5;

s2opend("/S2MONO",argc,argv); /* Open the display */
s2swin(x1-dx,x2+dx, y1-dy,y2+dy, z1-dz,z2+dz); /* Set window coords */
s2svp(-1,1,-1.5,1.5,-0.25,0.25);
s2box("BCDE",0,0,"BCDE",0,0,"BCDE",0,0); /* Draw coord box */

long N = 5000;

for (i=0;i<N;i++) { /* Create N random (x,y,z) values */
vi = (int)(drand48()*(nx));
vj = (int)(drand48()*(ny));
vk = (int)(drand48()*(nz));

volume[vi][vj][vk]+=1.0-drand48()*drand48();
/* Give a value to volume */
}

s2scir(1000,2000); /* Set colour range */
s2icm("mgreen",1000,2000); /* Install colour map */
vid = ns2cvr(volume, nx, ny, nz, 0, nx-1, 0, ny-1, 0, nz-1,
tr, trans, dmin, dmax, amin, amax);
/* Create the volume render object */

cs2scb(cb); /* Install a dynamic callback */

ss2srm(SHADE_FLAT); /* Set shading type to FLAT */
ss2sl(amb, 0, NULL, NULL, 0); /* Ambient lighting only */

ss2sas(1); /* Start the cube spinning */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2cvra

2009-01-06T22:27:41Z

Summary:

==ns2cvra==
Volume rendering with alpha function specified.

==Prototype==

<code><pre>
int ns2cvra(float ***grid,
int adim, int bdim, int cdim,
int a1, int a2, int b1, int b2, int c1, int c2,
float *tr, char trans,
float datamin, float datamax,
float(*ialphafn)(float*));
</pre></code>

==Description==
Volume rendering object, but with a function for alpha rather than a linear ramp. The ialphafn is called with a float (ptr) argument being the data value (which can be outside the (datamin, datamax) range of course) and should return a value between 0 (transparent) and 1 (opaque).

==See Also==
<table>
<tr><td>[[Function:ns2cvr | ns2cvr ]]</td><td>Create a volume rendering object. </td></tr>
<tr><td>[[Function:ns2svas | ns2svas ]]</td><td>Set alpha scaling mode. </td></tr>
<tr><td>[[Function:ns2qvas | ns2qvas]]</td><td>Query alpha scaling mode. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include "s2plot.h"

/* Global variables */
int vid; /* ID for volume render object */
float tr[12]; /* Transformation matrix */
float ***volume; /* The data cube */
int N = 5000; /* Number of data points */
float *x, *y, *z; /* Arrays for data values */

float ***initVolume(int nx, int ny, int nz)
/* Allocate memory and initialise a data cube */
{
float ***volume;
int i, j, k;

volume = (float ***)malloc(nx * sizeof(float **));
if (volume == NULL) {
fprintf(stderr,"Failed to allocate %ld bytes\n",(long)(nx*sizeof(float **)));
exit(-1);
}
for (i=0;i<nx;i++) {
volume[i] = (float **)malloc(ny * sizeof(float *));
if (volume[i] == NULL) {
fprintf(stderr,"Failed to allocate %ld bytes\n",(long)(nx*sizeof(float *)));
exit(-1);
}
for (j=0;j<ny;j++) {
volume[i][j] = (float *)malloc(nz * sizeof(float));
if (volume[i][j] == NULL) {
fprintf(stderr,"Failed to allocate %ld bytes\n",(long)(nx*sizeof(float)));
exit(-1);
}
for (k=0;k<nz;k++) {
volume[i][j][k] = 0.0; /* Initialise */
}
}
}

return volume;
}

void cb(double *t, int *kc)
/* A dynamic callback */
{
ds2dvr(vid, 1); /* Draw the volume render object */
if ((*kc % 2) == 1)
s2pt(N, x, y, z, 1); /* Plot the points on <space> press */
}

float dmin, dmax; /* Global variables for data range */

float transfer(float *dval) /* Alpha transfer function */
{
float davg = (dmax+dmin)/2.0;
if (*dval < davg) return 0.0;
else return 1.0;
}
int main(int argc, char *argv[])
{
int i; /* Loop variable */
int nx = 32, ny = 32, nz = 32; /* Dimensions of data cube */
float amin, amax; /* Min/max values */
char trans; /* Transparency mode */
float x1 = -1.0, x2 = +1.0; /* Data range along axes */
float y1 = -1.0, y2 = +1.0;
float z1 = -1.0, z2 = +1.0;
int vi, vj, vk; /* Temporary variables */
float dx, dy, dz; /* Temporary variables */
COLOUR amb = {0.8, 0.8, 0.8}; /* Ambient light */

srand48((long)time(NULL)); /* Seed random numbers */

volume = initVolume(nx, ny, nz); /* Allocate memory */

for (i=0;i<12;i++) { /* Set-up transfrom matrix */
tr[i] = 0.0;
}
tr[ 0] = x1; /* Mapping from data cube */
tr[ 1] = (x2-x1)/(float)(nx-1.0); /* to physical coordinates */
tr[ 4] = y1;
tr[ 6] = (y2-y1)/(float)(ny-1.0);
tr[ 8] = z1;
tr[11] = (z2-z1)/(float)(nz-1.0);

dmin = 0.0; /* Mininum data value in volume to plot */
dmax = 2.0; /* Maximum data value in volume to plot */
amin = 0.0; /* Minimum alpha channel value */
amax = 0.8; /* Maximum alpha channel value */
trans = 't'; /* Transparency type */

dx = tr[1]*0.5; /* Offsets for window - voxels are pixel */
dy = tr[6]*0.5; /* centred */
dz = tr[11]*0.5;

s2opend("/S2MONO",argc,argv); /* Open the display */
s2swin(x1-dx,x2+dx, y1-dy,y2+dy, z1-dz,z2+dz); /* Set window coords */
s2box("BCDE",0,0,"BCDE",0,0,"BCDE",0,0); /* Draw coord box */

x = (float *)calloc(N, sizeof(float));
y = (float *)calloc(N, sizeof(float));
z = (float *)calloc(N, sizeof(float));

for (i=0;i<N;i++) { /* Create N random (x,y,z) values */
vi = (int)(drand48()*(nx));
vj = (int)(drand48()*(ny));
vk = (int)(drand48()*(nz));
x[i] = vi * tr[1] + tr[0];
y[i] = vj * tr[6] + tr[4];
z[i] = vk * tr[11] + tr[8];

volume[vi][vj][vk]+=1.0-drand48()*drand48();
/* Give a value to volume */
}
s2scir(1000,2000); /* Set colour range */
s2icm("mgreen",1000,2000); /* Install colour map */
vid = ns2cvra(volume, nx, ny, nz, 0, nx-1, 0, ny-1, 0, nz-1,
tr, trans, dmin, dmax, transfer);
/* Create the volume render object */

cs2scb(cb); /* Install a dynamic callback */

fprintf(stderr,"Press <space> to toggle showing data points\n");

ss2srm(SHADE_FLAT); /* Set shading type to FLAT */
ss2sl(amb, 0, NULL, NULL, 0); /* Ambient lighting only */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2qsq

2009-01-06T22:27:24Z

Summary:

==ns2qsq==
Query general surface quality.

==Prototype==

<code><pre>
int ns2qsq(void);
</pre></code>

==Description==
Query general surface quality high (1) or low (0, default). The former calculates weighted normals for all vertices, while the latter calculates a single normal per facet of the surface. The former should be used for export to VRML.

==See Also==
<table>
<tr><td>[[Function:ns2ssq | ns2ssq]]</td><td>Set the general surface quality. </td></tr>
<tr><td>[[Function:ns2cis | ns2cis]]</td><td>Create an isosurface object. </td></tr>
<tr><td>[[Function:ns2cisc | ns2cisc]]</td><td>Create an isosurface object with a colour function.</td></tr>
<tr><td>[[Function:ns2dis | ns2dis ]]</td><td>Draw an isosurface object </td></tr>
<tr><td>[[Function:ns2sisl | ns2sisl ]]</td><td>Change the level of isosurface </td></tr>
<tr><td>[[Function:ns2sisc | ns2sisc]]</td><td>Set the colour for an isosurface. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "s2plot.h"

#define CELLS 30

int id1; /* Global variable: isosurface id */

void cb(double *t, int *kc)
{
char string[255];
int isq = ns2qsq(); /* Query the surface quality */
sprintf(string,"Surface quality is: %d. Press <space> to toggle",isq);
s2lab("","","",string); /* Show a label on screen */
ns2ssq(*kc%2); /* Set the surface quality */
ns2dis(id1, 1); /* Display an isosurface */

}

int main(int argc, char *argv[])
{
int i, j, k; /* Loop variables */
float x, y, z; /* Dummy variables for grid values */
int nx, ny, nz; /* Number of cells in grid */
float ***grid; /* Grid data */
float tr[12]; /* Transformation matrix */
int resolution; /* Resolution of isosurface */
float level; /* Isosurface level to plot */
float alpha; /* Alpha channel */
char trans; /* Drawing mode for isosurface */

nx = CELLS; /* Grid dimensions */
ny = CELLS;
nz = CELLS;

/* Create transpose matrix mapping data indices to world coords */
tr[0] = tr[4] = tr[8] = 0.0; /* Offsets */
tr[1] = tr[6] = tr[11] = 1.0; /* Increments */
tr[2] = tr[3] = tr[5] = tr[7] = tr[9] = tr[10] = 0.; /* Cross terms */

s2opend("/?",argc, argv); /* Open the display */
s2swin(0, nx-1, 0, ny-1, 0, nz-1); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

/* allocate and generate the data grid */
grid = (float ***)malloc(nx * sizeof(float **));
for (i = 0; i < nx; i++) {
grid[i] = (float **)malloc(ny * sizeof(float *));
x = (float)(i) / (float)(nx - 1);
for (j = 0; j < ny; j++) {
grid[i][j] = (float *)malloc(nz * sizeof(float));
y = (float)(j) / (float)(ny - 1);
for (k = 0; k < nz; k++) {
z = (float)(k) / (float)(nz - 1);
grid[i][j][k] = x*x*x + y*y - z*z*z*z;
}
}
}
level = 0.2; /* Set the isosurface level */
resolution = 1; /* Set the isosurface resolution */
alpha = 0.9; /* Set the alpha channel */
trans = 'o'; /* Opaque isosurface */

/* Create the isosurface object */

id1 = ns2cis(grid, nx, ny, nz, 0, nx-1, 0, ny-1, 0, nz-1,
tr, level, resolution, trans, alpha, 1., 1., 0.);

cs2scb(cb); /* Install dynamic callback */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2ssq

2009-01-06T22:27:01Z

Summary:

==ns2ssq==
Set general surface quality.

==Prototype==

<code><pre>
void ns2ssq(int hiq);
</pre></code>

==Description==
Set general surface quality high (1) or low (0, default). The former calculates weighted normals for all vertices, while the latter calculates a single normal per facet of the surface. The former should be used for export to VRML.

==See Also==
<table>
<tr><td>[[Function:ns2qsq | ns2qsq]]</td><td>Query the general surface quality. </td></tr>
<tr><td>[[Function:ns2cis | ns2cis]]</td><td>Create an isosurface object. </td></tr>
<tr><td>[[Function:ns2cisc | ns2cisc]]</td><td>Create an isosurface object with a colour function.</td></tr>
<tr><td>[[Function:ns2dis | ns2dis ]]</td><td>Draw an isosurface object </td></tr>
<tr><td>[[Function:ns2sisl | ns2sisl ]]</td><td>Change the level of isosurface </td></tr>
<tr><td>[[Function:ns2sisc | ns2sisc]]</td><td>Set the colour for an isosurface. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "s2plot.h"

#define CELLS 30

int id1; /* Global variable: isosurface id */

void cb(double *t, int *kc)
{
char string[255];
int isq = ns2qsq(); /* Query the surface quality */
sprintf(string,"Surface quality is: %d. Press <space> to toggle",isq);
s2lab("","","",string); /* Show a label on screen */
ns2ssq(*kc%2); /* Set the surface quality */
ns2dis(id1, 1); /* Display an isosurface */

}

int main(int argc, char *argv[])
{
int i, j, k; /* Loop variables */
float x, y, z; /* Dummy variables for grid values */
int nx, ny, nz; /* Number of cells in grid */
float ***grid; /* Grid data */
float tr[12]; /* Transformation matrix */
int resolution; /* Resolution of isosurface */
float level; /* Isosurface level to plot */
float alpha; /* Alpha channel */
char trans; /* Drawing mode for isosurface */

nx = CELLS; /* Grid dimensions */
ny = CELLS;
nz = CELLS;

/* Create transpose matrix mapping data indices to world coords */
tr[0] = tr[4] = tr[8] = 0.0; /* Offsets */
tr[1] = tr[6] = tr[11] = 1.0; /* Increments */
tr[2] = tr[3] = tr[5] = tr[7] = tr[9] = tr[10] = 0.; /* Cross terms */

s2opend("/?",argc, argv); /* Open the display */
s2swin(0, nx-1, 0, ny-1, 0, nz-1); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

/* allocate and generate the data grid */
grid = (float ***)malloc(nx * sizeof(float **));
for (i = 0; i < nx; i++) {
grid[i] = (float **)malloc(ny * sizeof(float *));
x = (float)(i) / (float)(nx - 1);
for (j = 0; j < ny; j++) {
grid[i][j] = (float *)malloc(nz * sizeof(float));
y = (float)(j) / (float)(ny - 1);
for (k = 0; k < nz; k++) {
z = (float)(k) / (float)(nz - 1);
grid[i][j][k] = x*x*x + y*y - z*z*z*z;
}
}
}
level = 0.2; /* Set the isosurface level */
resolution = 1; /* Set the isosurface resolution */
alpha = 0.9; /* Set the alpha channel */
trans = 'o'; /* Opaque isosurface */

/* Create the isosurface object */

id1 = ns2cis(grid, nx, ny, nz, 0, nx-1, 0, ny-1, 0, nz-1,
tr, level, resolution, trans, alpha, 1., 1., 0.);

cs2scb(cb); /* Install dynamic callback */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:zs2retainlists

2009-01-06T01:56:27Z

Summary:

==zs2retainlists==
Set retain lists.

==Prototype==

<code><pre>
void zs2retainlists(int retlists);
</pre></code>

==Description==
Set retain lists on or off.

==See Also==
<table>
<tr><td>[[Function:zs2debug |zs2debug]]</td><td>Set debugging on or off.</td></tr>
<tr><td>[[Function:zs2bufswap |zs2bufswap]]</td><td>Set buffer swapping.</td></tr>
<table>

==Code Example==

<code><pre>
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:zs2bufswap

2009-01-06T01:56:06Z

Summary:

==zs2bufswap==
Set buffer swapping.
==Prototype==

<code><pre>
void zs2bufswap(int bufswap);
</pre></code>

==Description==
Set buffer swapping on or off.

==See Also==
<table>
<tr><td>[[Function:zs2debug |zs2debug]]</td><td>Set debugging on or off.</td></tr>
<tr><td>[[Function:zs2retainlists |zs2retainlists]] </td><td>Set retain lists.</td></tr>
<table>

==Code Example==

<code><pre>
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:zs2debug

2009-01-06T01:55:46Z

Summary:

==zs2debug==
Set debugging on or off.

==Prototype==

<code><pre>
void zs2debug(int debug);
</pre></code>

==Description==
Set debugging on or off.

==See Also==
<table>
<tr><td>[[Function:zs2bufswap | zs2bufswap]]</td><td>Set the buffer swapping.</td></tr>
<tr><td>[[Function:zs2retainlists | zs2retainlists]]</td><td>Set retain lists.</td></tr>
<table>

==Code Example==

<code><pre>
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ss2g3dt

2009-01-06T01:55:31Z

Summary:

==ss2g3dt==
Fetch pointer to 3D texture.

==Prototype==

<code><pre>
unsigned char *ss2g3dt(unsigned int itextureID, int *width, int *height, int *depth);
</pre></code>

==Description==
Fetch pointer to 3D texture.

==See Also==
<table>
<tr><td>[[Function:ss2c3dt |ss2c3dt]]</td><td> Create an empty 3D texture.</td></tr>
<tr><td>[[Function:ns2texpoly3d |ns2texpoly3d]]</td><td> Draw a 3d texture.</td></tr>
<table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

unsigned int texid; /* 3D Texture ID */

void cb(double *t, int *kc)
{
int nverts = 4; /* Number of vertices in polygon */
char trans = 't'; /* 3d texture transparency */
float alpha = 0.7; /* Alpha channel value */

XYZ iP[4]; /* Array of polygon vertices */
XYZ iTC[4]; /* Array of texture coordinates */
static float texidx = 0.0; /* Current z-texture coordinate */

iP[0].x = iP[3].x = -1.0; /* Define polygon vertices */
iP[1].x = iP[2].x = +1.0;
iP[0].y = iP[1].y = +1.0;
iP[2].y = iP[3].y = -1.0;
iP[0].z = iP[1].z = iP[2].z = iP[3].z = texidx*2.0 - 1.0;

iTC[0].x = iTC[3].x = 0; /* Define texture coordinates */
iTC[1].x = iTC[2].x = 1;
iTC[0].y = iTC[1].y = 1;
iTC[2].y = iTC[3].y = 0;
iTC[0].z = iTC[1].z = iTC[2].z = iTC[3].z = texidx;

COLOUR col = { 1,1,1 }; /* Draw the polygon boundaries */
ns2vline(iP[0],iP[1],col);
ns2vline(iP[1],iP[2],col);
ns2vline(iP[2],iP[3],col);
ns2vline(iP[3],iP[0],col);

ns2texpoly3d(iP, iTC, nverts, texid, trans, alpha); /* Draw 3D texture */

texidx += (1.0/320.0); /* Choose next z-texture coordinate */
if (texidx > 1.0) texidx = 0.0;
}

int main(int argc, char *argv[])
{
int Nx = 32, Ny = 32, Nz = 32; /* Texture dimensions */
int w,h,d; /* Returned dimensions */

s2opend("/?",argc,argv); /* Open the s2plot display device */
s2swin(-1,1,-1,1,-1,1); /* Set the world coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0);

texid = ss2c3dt(Nx, Ny, Nz); /* Create a new 3d texture */
unsigned char *bits = (unsigned char *)ss2g3dt(texid, &w, &h, &d);
/* Get the texture data for modification */
int i, j, k;
long idx;
float x,y,z;
for (i=0;i<Nx;i++) {
x = -1.0 + i*(2.0/(float)(Nx-1));
for (j=0;j<Ny;j++) {
y = -1.0 + j*(2.0/(float)(Ny-1));
for (k=0;k<Nz;k++) {
z = -1.0 + k*(2.0/(float)(Nz-1));
idx = ((i*Ny + j)*Nz + k)*4;
if ((x*x + y*y + z*z) < 1.0) { /* 3D solid red sphere */
bits[idx + 1 ] = 255;
ns2point(x,y,z,1,1,1); /* Plot point in sphere */
} else {
bits[idx + 0 ] = 0;
}

bits[idx + 1 ] = 0; /* Blue channel */
bits[idx + 2 ] = 0; /* Green channel */
bits[idx + 3 ] = 255; /* Alpha channel */
}
}
}

fprintf(stderr, "3d texture IS %d x %d x %d\n", w, h, d);
ss2pt(texid); /* Push back the texture */

cs2scb(cb); /* Install a dynamic callback */

s2show(1); /* Display the geometry */

return 0;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ss2c3dt

2009-01-06T01:55:13Z

Summary:

==ss2c3dt==
Create an empty 3d texture.

==Prototype==

<code><pre>
unsigned int ss2c3dt(int width, int height, int depth);
</pre></code>

==Description==
Create an empty 3D texture.

==See Also==
<table>
<tr><td>[[Function:ss2g3dt |ss2g3dt]]</td><td> Fetch pointer to 3d texture.</td></tr>
<tr><td>[[Function:ns2texpoly3d |ns2texpoly3d]]</td><td> Draw a 3d texture.</td></tr>
<table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

unsigned int texid; /* 3D Texture ID */

void cb(double *t, int *kc)
{
int nverts = 4; /* Number of vertices in polygon */
char trans = 't'; /* 3d texture transparency */
float alpha = 0.7; /* Alpha channel value */

XYZ iP[4]; /* Array of polygon vertices */
XYZ iTC[4]; /* Array of texture coordinates */
static float texidx = 0.0; /* Current z-texture coordinate */

iP[0].x = iP[3].x = -1.0; /* Define polygon vertices */
iP[1].x = iP[2].x = +1.0;
iP[0].y = iP[1].y = +1.0;
iP[2].y = iP[3].y = -1.0;
iP[0].z = iP[1].z = iP[2].z = iP[3].z = texidx*2.0 - 1.0;

iTC[0].x = iTC[3].x = 0; /* Define texture coordinates */
iTC[1].x = iTC[2].x = 1;
iTC[0].y = iTC[1].y = 1;
iTC[2].y = iTC[3].y = 0;
iTC[0].z = iTC[1].z = iTC[2].z = iTC[3].z = texidx;

COLOUR col = { 1,1,1 }; /* Draw the polygon boundaries */
ns2vline(iP[0],iP[1],col);
ns2vline(iP[1],iP[2],col);
ns2vline(iP[2],iP[3],col);
ns2vline(iP[3],iP[0],col);

ns2texpoly3d(iP, iTC, nverts, texid, trans, alpha); /* Draw 3D texture */

texidx += (1.0/320.0); /* Choose next z-texture coordinate */
if (texidx > 1.0) texidx = 0.0;
}

int main(int argc, char *argv[])
{
int Nx = 32, Ny = 32, Nz = 32; /* Texture dimensions */
int w,h,d; /* Returned dimensions */

s2opend("/?",argc,argv); /* Open the s2plot display device */
s2swin(-1,1,-1,1,-1,1); /* Set the world coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0);

texid = ss2c3dt(Nx, Ny, Nz); /* Create a new 3d texture */
unsigned char *bits = (unsigned char *)ss2g3dt(texid, &w, &h, &d);
/* Get the texture data for modification */
int i, j, k;
long idx;
float x,y,z;
for (i=0;i<Nx;i++) {
x = -1.0 + i*(2.0/(float)(Nx-1));
for (j=0;j<Ny;j++) {
y = -1.0 + j*(2.0/(float)(Ny-1));
for (k=0;k<Nz;k++) {
z = -1.0 + k*(2.0/(float)(Nz-1));
idx = ((i*Ny + j)*Nz + k)*4;
if ((x*x + y*y + z*z) < 1.0) { /* 3D solid red sphere */
bits[idx + 1 ] = 255;
ns2point(x,y,z,1,1,1); /* Plot point in sphere */
} else {
bits[idx + 0 ] = 0;
}

bits[idx + 1 ] = 0; /* Blue channel */
bits[idx + 2 ] = 0; /* Green channel */
bits[idx + 3 ] = 255; /* Alpha channel */
}
}
}

fprintf(stderr, "3d texture IS %d x %d x %d\n", w, h, d);
ss2pt(texid); /* Push back the texture */

cs2scb(cb); /* Install a dynamic callback */

s2show(1); /* Display the geometry */

return 0;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2texpoly3d

2009-01-06T01:54:54Z

Summary:

==ns2texpoly3d==
Draw a 3-d textured polygon.

==Prototype==

<code><pre>
void ns2texpoly3d(XYZ *iP, XYZ *iTC, float in, unsigned int texid, char itrans, float ialpha);
</pre></code>

==Description==
Draw a 3-d textured polygon. The array iP holds the vertex coordinates, array iTC holds the texture coordinates,
parameter <tt>in</tt> is the number of vertices, itrans is one of 'o' (opaque), 't' (transparent) or 's' (standard) and
ialpha is the alpha channel value.
==See Also==
<table>
<tr><td>[[Function:ss2c3dt |ss2c3dt]]</td><td> Create an empty 3D texture.</td></tr>
<tr><td>[[Function:ss2g3dt |ss2g3dt]]</td><td> Fetch the pointer to a 3d texture.</td></tr>
<table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

unsigned int texid; /* 3D Texture ID */

void cb(double *t, int *kc)
{
int nverts = 4; /* Number of vertices in polygon */
char trans = 't'; /* 3d texture transparency */
float alpha = 0.7; /* Alpha channel value */

XYZ iP[4]; /* Array of polygon vertices */
XYZ iTC[4]; /* Array of texture coordinates */
static float texidx = 0.0; /* Current z-texture coordinate */

iP[0].x = iP[3].x = -1.0; /* Define polygon vertices */
iP[1].x = iP[2].x = +1.0;
iP[0].y = iP[1].y = +1.0;
iP[2].y = iP[3].y = -1.0;
iP[0].z = iP[1].z = iP[2].z = iP[3].z = texidx*2.0 - 1.0;

iTC[0].x = iTC[3].x = 0.0; /* Define texture coordinates */
iTC[1].x = iTC[2].x = 1.0;
iTC[0].y = iTC[1].y = 1.0;
iTC[2].y = iTC[3].y = 0.0;
iTC[0].z = iTC[1].z = iTC[2].z = iTC[3].z = texidx;

COLOUR col = { 1,1,1 }; /* Draw the polygon boundaries */
ns2vline(iP[0],iP[1],col);
ns2vline(iP[1],iP[2],col);
ns2vline(iP[2],iP[3],col);
ns2vline(iP[3],iP[0],col);

ns2texpoly3d(iP, iTC, nverts, texid, trans, alpha); /* Draw 3D texture */

texidx += (1.0/320.0); /* Choose next z-texture coordinate */
if (texidx > 1.0) texidx = 0.0;
}

int main(int argc, char *argv[])
{
int Nx = 32, Ny = 32, Nz = 32; /* Texture dimensions */
int w,h,d; /* Returned dimensions */

s2opend("/?",argc,argv); /* Open the s2plot display device */
s2swin(-1,1,-1,1,-1,1); /* Set the world coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0);

texid = ss2c3dt(Nx, Ny, Nz); /* Create a new 3d texture */
unsigned char *bits = (unsigned char *)ss2g3dt(texid, &w, &h, &d);
/* Get the texture data for modification */
int i, j, k;
long idx;
float x,y,z;
for (i=0;i<Nx;i++) {
x = -1.0 + i*(2.0/(float)(Nx-1));
for (j=0;j<Ny;j++) {
y = -1.0 + j*(2.0/(float)(Ny-1));
for (k=0;k<Nz;k++) {
z = -1.0 + k*(2.0/(float)(Nz-1));
idx = ((i*Ny + j)*Nz + k)*4;
if ((x*x + y*y + z*z) < 1.0) { /* 3D solid red sphere */
bits[idx + 1 ] = 255;
ns2point(x,y,z,1,1,1); /* Plot point in sphere */
} else {
bits[idx + 0 ] = 0;
}

bits[idx + 1 ] = 0; /* Blue channel */
bits[idx + 2 ] = 0; /* Green channel */
bits[idx + 3 ] = 255; /* Alpha channel */
}
}
}

fprintf(stderr, "3d texture IS %d x %d x %d\n", w, h, d);
ss2pt(texid); /* Push back the texture */

cs2scb(cb); /* Install a dynamic callback */

s2show(1); /* Display the geometry */

return 0;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ss2qcs

2009-01-06T01:54:32Z

Summary:

==ss2qcs==
Set/query the camera speed.
==Prototype==

<code><pre>
float ss2qcs(void);
</pre></code>

==Description==
Set/query the camera speed (ie. increment amount for camera movements. Values between 0.01 and 20.0 are reasonably sensible.

==See Also==
<table>
<tr><td>[[Function:ss2scs | ss2scs ]]</td><td>Set the camera speed. </td></tr>
<tr><td>[[Function:ss2qca | ss2qca ]]</td><td>Query the camera aperture. </td></tr>
<tr><td>[[Function:ss2sca | ss2sca ]]</td><td>Set the camera aperture. </td></tr>
<tr><td>[[Function:ss2sc | ss2sc ]]</td><td>Set the camera position, up vector and view direction. </td></tr>
<tr><td>[[Function:ss2qc | ss2qc ]]</td><td>Query the camera position, up vector and view direction. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "s2plot.h"

void cb(double *t, int *kc)
{
static int lkc = 0; /* Count of key presses */

float qcs = ss2qcs(); /* Query camera increment */
char string[32];

sprintf(string,"%.2f",qcs);
s2textxy(0,0,0,string); /* Display text */

lkc = *kc; /* Update count */
}

int main(int argc, char *argv[])
{

srand48((long)time(NULL)); /* Seed random numbers */
s2opend("/s2mono",argc, argv); /* Open the display: mono */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDE",0,0,"BCDE",0,0,"BCDE",0,0); /* Draw coordinate box */

s2lab("","","","Press < and > to change camera movement increment, then +/- to test zooming\n");

cs2scb(cb); /* Install dynamic callback */
s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ss2scs

2009-01-06T01:54:12Z

Summary:

==ss2scs==
Set the camera speed.

==Prototype==

<code><pre>
void ss2scs(float spd);
</pre></code>

==Description==
Set the camera speed (ie. increment amount for camera movements. Values between 0.01 and 20.0 are reasonably sensible.

==See Also==
<table>
<tr><td>[[Function:ss2qcs | ss2qcs ]]</td><td>Query the camera speed. </td></tr>
<tr><td>[[Function:ss2qca | ss2qca ]]</td><td>Query the camera aperture. </td></tr>
<tr><td>[[Function:ss2sca | ss2sca ]]</td><td>Set the camera aperture. </td></tr>
<tr><td>[[Function:ss2sc | ss2sc ]]</td><td>Set the camera position, up vector and view direction. </td></tr>
<tr><td>[[Function:ss2qc | ss2qc ]]</td><td>Query the camera position, up vector and view direction. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "s2plot.h"

void cb(double *t, int *kc)
{
static int lkc = 0; /* Count of key presses */
static float spd = 1.0; /* Set the camera increment */

if (lkc != *kc) { /* Query whether <space> was pressed */
spd += 2.0; /* Update the camera increment */
}
ss2scs(spd); /* Set the new camera increment */

char string[32]; /* Write current increment to screen */
sprintf(string,"%.2f",spd);
s2textxy(0,0,0,string); /* Display text */

lkc = *kc; /* Update key press count */
}

int main(int argc, char *argv[])
{

srand48((long)time(NULL)); /* Seed random numbers */
s2opend("/s2mono",argc, argv); /* Open the display: mono */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDE",0,0,"BCDE",0,0,"BCDE",0,0); /* Draw coordinate box */

s2lab("","","","Press <space> to change camera movement increment, then +/- to test zooming\n");

cs2scb(cb); /* Install dynamic callback */
s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ss2qca

2009-01-06T01:53:57Z

Summary:

==ss2qca==
Query the camera aperture.
==Prototype==

<code><pre>
float ss2qca(void);
</pre></code>

==Description==
Query the camera aperture (in degrees).

==See Also==
<table>
<tr><td>[[Function:ss2sca | ss2sca ]]</td><td>Set the camera aperture. </td></tr>
<tr><td>[[Function:ss2scs | ss2scs ]]</td><td>Set the camera speed. </td></tr>
<tr><td>[[Function:ss2qcs | ss2qcs ]]</td><td>Query the camera speed. </td></tr>
<tr><td>[[Function:ss2sc | ss2sc ]]</td><td>Set the camera position, up vector and view direction. </td></tr>
<tr><td>[[Function:ss2qc | ss2qc ]]</td><td>Query the camera position, up vector and view direction. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "s2plot.h"

void cb(double *t, int *kc)
{
int N = 100; /* Number of points */
static int flag = -1; /* Flag for initialisation */
static XYZ xyz[100]; /* Array of point positions */
static COLOUR col[100]; /* Array of colours */
int i; /* Loop variable */

if (flag < 0) { /* First time through? */
for (i=0;i<N;i++) {
xyz[i].x = drand48()*2.0 - 1.0; /* Random data positions */
xyz[i].y = drand48()*2.0 - 1.0;
xyz[i].z = drand48()*2.0 - 1.0;
col[i].r = drand48(); /* Random data colours */
col[i].g = drand48();
col[i].b = drand48();
}
flag = 1; /* Set the flag */
}

for (i=0;i<N;i++) {
ns2vthpoint(xyz[i], col[i], 3); /* Draw the point */
}

static int lkc = 1; /* Last time <space> key pressed */
if (lkc != *kc) /* Check for keyboard press */
ss2sca(drand48()*70 + 20); /* Set the camera aperture */
lkc = *kc; /* Update key press */

int wc = ss2qca(); /* Query camera aperture */
char text[64];
sprintf(text, "Aperture %d degrees\n",wc); /* Prepare a text string */
s2textxy(0.0,0.0,0.0, text); /* Display text string */

s2lab("","","","Press <space> to change camera aperture");
}

int main(int argc, char *argv[])
{

srand48((long)time(NULL)); /* Seed random numbers */

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

cs2scb(cb); /* Install a dynamic callback */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ss2sca

2009-01-06T01:53:41Z

Summary:

==ss2sca==
Set the camera aperture.

==Prototype==

<code><pre>
void ss2sca(float aperture);
</pre></code>

==Description==
Set the camera aperture (in degrees).

==See Also==
<table>
<tr><td>[[Function:ss2qca | ss2qca ]]</td><td>Query the camera aperture. </td></tr>
<tr><td>[[Function:ss2scs | ss2scs ]]</td><td>Set the camera speed. </td></tr>
<tr><td>[[Function:ss2qcs | ss2qcs ]]</td><td>Query the camera speed. </td></tr>
<tr><td>[[Function:ss2sc | ss2sc ]]</td><td>Set the camera position, up vector and view direction. </td></tr>
<tr><td>[[Function:ss2qc | ss2qc ]]</td><td>Query the camera position, up vector and view direction. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "s2plot.h"

void cb(double *t, int *kc)
{
int N = 100; /* Number of points */
static int flag = -1; /* Flag for initialisation */
static XYZ xyz[100]; /* Array of point positions */
static COLOUR col[100]; /* Array of colours */
int i; /* Loop variable */

if (flag < 0) { /* First time through? */
for (i=0;i<N;i++) {
xyz[i].x = drand48()*2.0 - 1.0; /* Random data positions */
xyz[i].y = drand48()*2.0 - 1.0;
xyz[i].z = drand48()*2.0 - 1.0;
col[i].r = drand48(); /* Random data colours */
col[i].g = drand48();
col[i].b = drand48();
}
flag = 1; /* Set the flag */
}

for (i=0;i<N;i++) {
ns2vthpoint(xyz[i], col[i], 3); /* Draw the point */
}

static int lkc = 1; /* Last time <space> key pressed */
if (lkc != *kc) /* Check for keyboard press */
ss2sca(drand48()*70 + 20); /* Set the camera aperture */
lkc = *kc; /* Update key press */

int wc = ss2qca(); /* Query camera aperture */
char text[64];
sprintf(text, "Aperture %d degrees\n",wc); /* Prepare a text string */
s2textxy(0.0,0.0,0.0, text); /* Display text string */

s2lab("","","","Press <space> to change camera aperture");
}

int main(int argc, char *argv[])
{

srand48((long)time(NULL)); /* Seed random numbers */

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

cs2scb(cb); /* Install a dynamic callback */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:xs2spp

2009-01-06T01:53:27Z

Summary:

==xs2spp==
Set panel frame properties.

==Prototype==

<code><pre>
void xs2spp(COLOUR active, COLOUR inactive, float width);
</pre></code>

==Description==
Set panel frame properties.

==See Also==
<table>
<tr><td>[[Function:xs2ap | xs2ap]]</td><td>Add a new panel</td><td> </td></tr>
<tr><td>[[Function:xs2mp | xs2mp]]</td><td>Modify location of existing panel.</td><td> </td></tr>
<tr><td>[[Function:xs2cp | xs2cp]]</td><td>Select a panel for subsequent geometry calls</td><td> </td></tr>
<tr><td>[[Function:xs2tp | xs2tp]]</td><td>Toggle visibility of panel</td><td> </td></tr>
<tr><td>[[Function:xs2lpc | xs2lpc]]</td><td>Link panel cameras together</td><td> </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

/* Global variales used in callback */
int master_panel = 0; /* Default ID of main panel */
int slave_panel; /* ID of newly created panel */

void cb(double *t, int *kc)
{
static int lkc = 0; /* Keep count of keypress state */
if (*kc == 1) {
xs2lpc(master_panel, slave_panel); /* Link panels together */
} else if ((*kc > 1) && (*kc != lkc)) {
xs2tp(slave_panel); /* Toggle panel visiblity */
}

lkc = *kc; /* Update count of keypress state */
}

int main(int argc, char *argv[])
{
s2opend("/s2mono", argc, argv); /* Open in mono mode */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

xs2mp(master_panel, 0.0, 0.5, 0.5, 1.0); /* Move to top left */

slave_panel = xs2ap(0.5, 0.0, 1.0, 0.5); /* Create panel in bottom right */
xs2cp(slave_panel); /* Choose this panel */
s2swin(-2.,2., -2.,2., -2.,2.); /* Set the window coordinates */
s2box("BCDE",0,0,"BCDE",0,0,"BCDE",0,0); /* Draw coordinate box */

xs2cp(master_panel); /* Go back to main panel */
cs2scb(cb); /* Install dynamic callback */

COLOUR inactive = { 0.3, 0.2, 0.8 }; /* Inactive frame colour */
COLOUR active = { 0.1, 1.0, 0.1 }; /* Active frame colour */
float width = 2.0; /* Frame border width */
xs2spp(active, inactive, width); /* Set panel properties */

fprintf(stderr,"Press <tab> to switch between panels\n");
fprintf(stderr,"Press <spacebar> to link cameras together - cannot be undone\n");
fprintf(stderr,"Futher presses of <spacebar> toggle panel visiblity\n");

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:cs2sptxy

2009-01-06T01:53:10Z

Summary:

==cs2sptxy==
Set the text and position of a prompt.

==Prototype==

<code><pre>
void cs2sptxy(char *prompt, float xfrac, float yfrac);
</pre></code>

==Description==
Set the text and position of the prompt. xfrac and yfrac are fractions of the viewport from bottom left.

==See Also==
<table>
<tr><td>[[Function:cs2spcb | cs2spcb]]</td><td>Set the user prompt callback.</td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

/* Global variable */
float r = 0, g = 0, b = 0; /* Background colour */

void pcb(char *string)
{
int res; /* How many numbers entered? */
float rr, gg, bb; /* Local variables */
res = sscanf(string,"%f %f %f",&rr,&gg,&bb); /* Read from prompt string */
if (res == 3) {
r = rr; /* Change background colour */
g = gg;
b = bb;
}

/* Change where the prompt appears next time */
float px = drand48()*0.6 + 0.2;
float py = drand48()*0.6 + 0.2;

cs2sptxy("R G B >", px, py);
}

void cb(double *t, int *kc)
{
ss2sbc(r, g, b); /* Set background colour */
ss2sfc(1-r, 1-g, 1-b); /* Choose sensible foreground */
s2scr(32, 1-r, 1-g, 1-b); /* Create a new colour index */
s2sci(32); /* Set colour to this index */
s2textxy(-1,0,0,"Press ~ then enter R G B values e.g 1 1 1");
/* Write some text */

}

int main(int argc, char *argv[])
{
s2opend("/s2mono", argc, argv); /* Open in mono mode */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

cs2scb(cb); /* Install dynamic callback */

char string[32]; /* Allocate prompt string memory */
cs2spcb(pcb, string); /* Install a prompt callback */

s2lab("","","","Demonstrates positioning of the prompt");

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ds2vbbp

2009-01-06T01:52:48Z

Summary:

==ds2vbbp==
Draw a "billboard" with aspect ratio - vector input.

==Prototype==

<code><pre>
void ds2vbbp(XYZ iP, XYZ offset, float aspect,
float isize, COLOUR iC, unsigned int itexid, float alpha, char trans);
</pre></code>

==Description==
Draw a "billboard" with aspect ratio: width:height instead of stretch, and offset in screen coords (x,y) [offset.z ignored].

==See Also==
<table>
<tr><td>[[Function:ds2vbbpr | ds2vbbpr]]</td><td>Billboard with aspect ratio, offset in screen coords, and rotation of texture - vector input.</td></tr>
<tr><td>[[Function:ds2bbset | ds2bbset ]]</td><td>Draw a set of billboards. </td></tr>
<tr><td>[[Function:ds2bb | ds2bb ]]</td><td>Draw a (dynamic) billboard: a textured facet that always faces the camera. </td></tr>
<tr><td>[[Function:ds2vbb | ds2vbb ]]</td><td>Draw a (dynamic) billboard: a textured facet that always faces the camera - vector input </td></tr>
<tr><td>[[Function:ds2vbbr | ds2vbbr ]]</td><td>Draw a (dynamic) billboard texture with specified rotation.</td></tr>
<tr><td>[[Function:ds2tb | ds2tb ]]</td><td>Draw text that always faces the camera </td></tr>
<tr><td>[[Function:ds2vtb | ds2vtb ]]</td><td>Draw text that always faces the camera - vector input </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "s2plot.h"

unsigned int tid;

void cb(double *t, int *kc)
{
XYZ xyz = {0.0, 0.3, 0.4}; /* Location */
float isize = 0.05; /* Texture scale */
XYZ offset = { 0.2, 0.1, 0.0}; /* Texture offset to reference point */
float aspect = 2.2; /* Aspect ratio */
COLOUR col = { 1.0, 1.0, 0.0 }; /* Yellow */
float alpha = 0.9; /* Alpha channel */
char trans = 's'; /* Transparency */

ds2vbbp(xyz, offset, aspect, isize, col, tid, alpha, trans);
/* Billboard with aspect ratio and offset */
ns2vthpoint(xyz, col, 3); /* Plot texture reference point */

xyz.y = -0.3; /* Change the y value */
XYZ str = { 0.0, 0.0, 0.0 }; /* No stretch */
ds2vbb(xyz, str, isize, col, tid, alpha, trans); /* Standard billboard */
ns2vthpoint(xyz, col, 3); /* Plot texture reference point */
}

int main(int argc, char *argv[])
{
int width = 16, height = 16; /* Dimensions of texture */
int i, j; /* Loop variables */
int idx; /* Index into texture array */
unsigned char *tex; /* Array of texture values */

srand48((long)time(NULL)); /* Seed random numbers */
s2opend("/?",argc,argv); /* Open the display */
s2svp(-1.0,1.0, -1.0,1.0, -1.0,1.0); /* Set the viewport coords */
s2swin(-1.0,1.0, -1.0,1.0, -1.0,1.0); /* Set the window coordinates */
s2box("BCDE",0,0,"BCDE",0,0,"BCDE",0,0); /* Draw a bounding box */

tid = ss2ct(width, height); /* Create a new texture */
tex = ss2gt(tid, &width, &height); /* Get the texture */

for (j=0;j<height;j++) {
for (i=0;i<width;i++) {
idx = (j*width + i) * 4; /* Stored as (r,g,b,alpha) */
tex[idx ] = 127*drand48()+128; /* Randomish red */
tex[idx+1] = 0; /* Green */
tex[idx+2] = 0; /* Blue */
/* Do nothing to alpha */
}
}
ss2pt(tid); /* Push texture for usage */

cs2scb(&cb); /* Install a callback */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2scube

2009-01-06T01:52:29Z

Summary:

==ns2scube==
Draw a solid cube.

==Prototype==

<code><pre>
void ns2scube(float x1, float y1, float z1, float x2, float y2, float z2,
float red, float green, float blue,float alpha);
</pre></code>

==Description==
Draw a solid cube with filled but transparent faces.

==See Also==
<table>
<tr><td>[[Function:s2wcube | s2wcube ]]</td><td>Draw a wireframe cube.</td></tr>
<tr><td>[[Function:ns2vscube |ns2vscube ]]</td><td>Draw a solid cube - vector input. </td></tr>
<tr><td>[[Function:ns2thwcube | ns2thwcube ]]</td><td>Draw a wireframe cube. </td></tr>
<tr><td>[[Function:ns2vthwcube | ns2vthwcube ]]</td><td>Draw a wireframe cube - vector input. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

int main(int argc, char *argv[])
{
char xopt[] = "BCDETMNOPQ";
char yopt[] = "BCDETMNOPQ";
char zopt[] = "BCDETMNOPQ";

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box(xopt, 0,0, yopt, 0,0, zopt, 0,0); /* Draw the coordinate box */
s2lab("X-axis","Y-axis","Z-axis","Plot"); /* Write some labels */

float x1 = -0.8, x2 = +0.8; /* Box coordinates */
float y1 = -0.8, y2 = +0.8;
float z1 = -0.8, z2 = +0.8;

float r = 1.0, g = 0.3, b = 0.2; /* RGB colours */
float alpha = 0.4; /* Alpha channel transparency */

ns2scube(x1,y1,z1, x2,y2,z2, r,g,b, alpha);

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2vthcline

2009-01-06T01:52:06Z

Summary:

==ns2vthcline==
Draw a thick coloured line - vector input.

==Prototype==

<code><pre>
void ns2vthcline(XYZ P1, XYZ P2, COLOUR col1, COLOUR col2, float width);
</pre></code>

==Description==
Draw a thick coloured line, with colour blended between the two given colours along the line, and given width.

==See Also==
<table>
<tr><td>[[Function:ns2thcline | ns2thcline ]]</td><td>Draw a thick coloured line. </td></tr>
<tr><td>[[Function:ns2line | ns2line ]]</td><td>Draw a line from one point to another in a specific colour.</td></tr>
<tr><td>[[Function:ns2vline | ns2vline ]]</td><td>Draw a line from one point to another in a specific colour - vector input. </td></tr>
<tr><td>[[Function:ns2thline | ns2thline ]]</td><td>Draw a thick line from one point to another in a specific colour. </td></tr>
<tr><td>[[Function:ns2vthline | ns2vthline ]]</td><td>Draw a thick line from one point to another in a specific colour - vector input. </td></tr>
<tr><td>[[Function:ns2cline | ns2cline ]]</td><td>Draw a coloured line, with colour blended between the two given colours along the line. </td></tr>
<tr><td>[[Function:ns2vcline | ns2vcline ]]</td><td>Draw a coloured line, with colour blended between the two given colours along the line - vector input. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "s2plot.h"

int main(int argc, char *argv[])
{
XYZ start; /* Start of line */
XYZ end; /* End of line */
COLOUR col1; /* Colour of line segment (start) */
COLOUR col2; /* Colour of line segment (end) */
float size; /* Line thickness */
int N = 10; /* Number of lines */
int i; /* Loop variable */

srand48((long)time(NULL)); /* Seed random numbers */
s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

s2sci(S2_PG_YELLOW); /* Set colour */
for (i=0;i<N;i++) {
start.x = drand48()*2.0 - 1.0; /* Random (x,y,z) coordinates */
start.y = drand48()*2.0 - 1.0;
start.z = drand48()*2.0 - 1.0;
end.x = drand48()*2.0 - 1.0; /* Random (x,y,z) coordinates */
end.y = drand48()*2.0 - 1.0;
end.z = drand48()*2.0 - 1.0;
col1.r = drand48();
col1.g = drand48();
col1.b = drand48();
col2.r = drand48();
col2.g = drand48();
col2.b = drand48();
size = drand48()*10.0;
ns2vthcline(start, end, col1, col2, size); /* Draw the thick line */
}

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2thcline

2009-01-06T01:51:44Z

Summary:

==ns2cline==
Draw a thick coloured line.

==Prototype==

<code><pre>
void ns2thcline(float x1, float y1, float z1, float x2, float y2, float z2,
float red1, float green1,
float blue1, float red2, float green2, float blue2,float width);
</pre></code>

==Description==
Draw a thick coloured line, with colour blended between the two given colours along the line, and given width.

==See Also==
<table>
<tr><td>[[Function:ns2vthcline | ns2vthcline ]]</td><td>Draw a thick coloured line - vector input. </td></tr>
<tr><td>[[Function:ns2line | ns2line ]]</td><td>Draw a line from one point to another in a specific colour.</td></tr>
<tr><td>[[Function:ns2vline | ns2vline ]]</td><td>Draw a line from one point to another in a specific colour - vector input. </td></tr>
<tr><td>[[Function:ns2thline | ns2thline ]]</td><td>Draw a thick line from one point to another in a specific colour. </td></tr>
<tr><td>[[Function:ns2vthline | ns2vthline ]]</td><td>Draw a thick line from one point to another in a specific colour - vector input. </td></tr>
<tr><td>[[Function:ns2cline | ns2cline ]]</td><td>Draw a coloured line, with colour blended between the two given colours along the line. </td></tr>
<tr><td>[[Function:ns2vcline | ns2vcline ]]</td><td>Draw a coloured line, with colour blended between the two given colours along the line - vector input. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "s2plot.h"

int main(int argc, char *argv[])
{
float x1, y1, z1; /* Start of line */
float x2, y2, z2; /* End of line */
float r1, g1, b1; /* Colour of line segment (start) */
float r2, g2, b2; /* Colour of line segment (end) */
float size; /* Thickness of line */
int N = 10; /* Number of lines */
int i; /* Loop variable */

srand48((long)time(NULL)); /* Seed random numbers */
s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

s2sci(S2_PG_YELLOW); /* Set colour */
for (i=0;i<N;i++) {
x1 = drand48()*2.0 - 1.0; /* Random (x,y,z) coordinates */
y1 = drand48()*2.0 - 1.0;
z1 = drand48()*2.0 - 1.0;
x2 = drand48()*2.0 - 1.0; /* Random (x,y,z) coordinates */
y2 = drand48()*2.0 - 1.0;
z2 = drand48()*2.0 - 1.0;
r1 = drand48();
g1 = drand48();
b1 = drand48();
r2 = drand48();
g2 = drand48();
b2 = drand48();
size = drand48()*10.0; /* Line thickness */
ns2thcline(x1,y1,z1, x2,y2,z2, r1,g1,b1, r2,g2,b2, size); /* Draw the thick line */
}

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2vthwcube

2009-01-06T01:51:27Z

Summary:

==ns2vthwcube==
Draw a cube - vector input.

==Prototype==

<code><pre>
void ns2vthwcube(XYZ P1, XYZ P2, COLOUR col, float width);
</pre></code>

==Description==
Draw a wireframe cube (with axes parallel to the coordinate axes) in a specific colour and thickness

==See Also==
<table>
<tr><td>[[Function:ns2thwcube | ns2thwcube ]]</td><td>Draw a wireframe cube. </td></tr>
<tr><td>[[Function:s2wcube | s2wcube ]]</td><td>Draw a wireframe cube. </td></tr>
<tr><td>[[Function:ns2scube | ns2scube ]]</td><td>Draw a solid cube.</td></tr>
<tr><td>[[Function:ns2vscube |ns2vscube ]]</td><td>Draw a solid cube - vector input. </td></tr>

</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

int main(int argc, char *argv[])
{
char xopt[] = "BCDETMNOPQ";
char yopt[] = "BCDETMNOPQ";
char zopt[] = "BCDETMNOPQ";

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box(xopt, 0,0, yopt, 0,0, zopt, 0,0); /* Draw the coordinate box */
s2lab("X-axis","Y-axis","Z-axis","Plot"); /* Write some labels */

XYZ xyz1 = { -0.8, -0.8, -0.8 }; /* Box coordinate */
XYZ xyz2 = { +0.8, +0.8, +0.8 }; /* Box coordinate */

COLOUR col = { 1.0, 0.3, 0.2 }; /* RGB colours */

float w = 2.0; /* Box border width */

ns2vthwcube(xyz1, xyz2, col, w);

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2thwcube

2009-01-06T01:51:11Z

Summary:

==ns2thwcube==
Draw a wireframe cube.

==Prototype==

<code><pre>
void ns2thwcube(float x1, float y1, float z1, float x2, float y2, float z2,
float red, float green, float blue, float width);
</pre></code>

==Description==
Draw a wireframe cube (with axes parallel to the coordinate axes) in a specific colour and thickness.

==See Also==
<table>
<tr><td>[[Function:ns2vthwcube | ns2vthwcube ]]</td><td>Draw a wireframe cube - vector input. </td></tr>
<tr><td>[[Function:s2wcube | s2wcube ]]</td><td>Draw a wireframe cube. </td></tr>
<tr><td>[[Function:ns2scube | ns2scube ]]</td><td>Draw a solid cube.</td></tr>
<tr><td>[[Function:ns2vscube |ns2vscube ]]</td><td>Draw a solid cube - vector input. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

int main(int argc, char *argv[])
{
char xopt[] = "BCDETMNOPQ";
char yopt[] = "BCDETMNOPQ";
char zopt[] = "BCDETMNOPQ";

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box(xopt, 0,0, yopt, 0,0, zopt, 0,0); /* Draw the coordinate box */
s2lab("X-axis","Y-axis","Z-axis","Plot"); /* Write some labels */

float x1 = -0.8, x2 = +0.8; /* Box coordinates */
float y1 = -0.8, y2 = +0.8;
float z1 = -0.8, z2 = +0.8;

float r = 1.0, g = 0.3, b = 0.2; /* RGB colours */

float w = 2.0; /* Box border width */

ns2thwcube(x1,y1,z1, x2,y2,z2, r,g,b, w);

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2verc

2009-01-06T01:50:52Z

Summary:

==ns2verc==
Draw an arc - vector input.

==Prototype==

<code><pre>
void ns2verc(XYZ P, XYZ N, XYZ S, float deg, int nseg, float axratio);
</pre></code>

==Description==
Draw an arc with specified major/minor axis ratio. The major axis is given by the starting vector.

==See Also==
<table>
<tr><td> [[Function:ns2erc |ns2erc]]</td><td>Draw an arc.</td></tr>
<tr><td> [[Function:ns2arc |ns2arc]]</td><td>Draw an arc at (px,py,pz) with normal (nx,ny,nz) in current pen (thickness,colour)..</td></tr>
<tr><td>[[Function:ns2varc | ns2varc ]]</td><td>Draw an arc at (px,py,pz) with normal (nx,ny,nz) in current pen (thickness,colour) - vector input. </td></tr>
<tr><td>[[Function:s2line |s2line]]</td><td>Draw a poly line, n vertices at (xpts, ypts, zpts).</td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

int main(int argc, char *argv[])
{
XYZ pos; /* Position */
XYZ normal; /* Normal */
XYZ start; /* Starting vector */
float deg = 180.0; /* Angular extent */
int nseg = 48; /* Number of segments */

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

pos.x = 0.0; pos.y = 0.0; pos.z = 0.0; /* Set position */
normal.x = 0.0; normal.y = 1.0; normal.z = 1.0; /* Normal vector */
start.x = 1.0; start.y = 0.0; start.z = 0.0; /* Normal vector */

s2slw(3); /* Set line width */
s2sci(S2_PG_YELLOW); /* Set the colour */

float axratio = 2.0;

ns2verc(pos, normal, start, deg, nseg, axratio); /* Draw the arc */
s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2erc

2009-01-06T01:50:37Z

Summary:

==ns2erc==
Draw an arc.

==Prototype==

<code><pre>
void ns2erc(float px, float py, float pz,
float nx, float ny, float nz,
float sx, float sy, float sz,
float deg, int nseg, float axratio);
</pre></code>

==Description==
Draw an arc with specified major/minor axis ratio. The major axis is given by the starting vector.

==See Also==
<table>
<tr><td> [[Function:ns2verc |ns2verc]]</td><td>Draw an arc - vector input.</td></tr>
<tr><td> [[Function:ns2arc |ns2arc]]</td><td>Draw an arc at (px,py,pz) with normal (nx,ny,nz) in current pen (thickness,colour).</td></tr>
<tr><td>[[Function:ns2varc | ns2varc ]]</td><td>Draw an arc at (px,py,pz) with normal (nx,ny,nz) in current pen (thickness,colour) - vector input. </td></tr>
<tr><td>[[Function:s2line |s2line]]</td><td>Draw a poly line, n vertices at (xpts, ypts, zpts).</td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

int main(int argc, char *argv[])
{
float px, py, pz; /* Position */
float nx, ny, nz; /* Normal */
float sx, sy, sz; /* Starting vector */
float deg = 180.0; /* Angular extent */
int nseg = 48; /* Number of segments */

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

px = 0.0; py = 0.0; pz = 0.0; /* Set position */
nx = 0.0; ny = 1.0; nz = 1.0; /* Normal vector */
sx = 1.0; sy = 0.0; sz = 0.0; /* Starting vector */

s2slw(3); /* Set line width */
s2sci(S2_PG_YELLOW); /* Set the colour */

float axratio = 0.5;
ns2erc(px,py,pz, nx,ny,nz, sx,sy,sz, deg, nseg, axratio);
/* Draw the arc */
s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2vplanetx

2009-01-06T01:50:16Z

Summary:

==ns2vplanetx==
Draw a planet with texture id.

==Prototype==

<code><pre>
void ns2vplanetx(XYZ iP, float ir, COLOUR icol, unsigned int itextureid,
float texture_phase, XYZ axis, float rotation);
</pre></code>

==Description==
Draw a planet, which is a textured sphere whose texture can be "slid" around the planet, and the planet then rotated about an arbitrary axis. Texture phase is in the range [0..1], while rotation angle is in degrees.

==See Also==
<table>
<tr><td>[[Function:ns2vplanett | ns2vplanett]]</td><td>Draw a planet - vector input.</td></tr>
<tr><td>[[Function:ns2vsphere | ns2vsphere ]]</td><td>Draw a sphere, with a given centre, radius and colour - vector input.</td></tr>
<tr><td>[[Function:ns2spheret | ns2spheret]]</td><td>Draw a textured sphere, with given centre, radius, colour and texture filename </td></tr>
<tr><td>[[Function:ns2vspheret | ns2vspheret]]</td><td>Draw a textured sphere, with given centre, radius, colour and texture filename - vector input.</td></tr>
<tr><td>[[Function:ns2spherex| ns2spherex]]</td><td>Draw a textured sphere, with given centre, radius, colour and texture ID</td></tr>
<tr><td>[[Function:ns2vspherex | ns2vspherex]]</td><td>Draw a textured sphere, with given centre, radius, colour and texture ID - vector input.</td></tr>
<tr><td>[[Function:ns2sphere| ns2sphere]]</td><td>Draw a sphere.</td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

void cb(double *t, int *kc)
{
float radius = 0.5; /* Radius of planet */
XYZ xyz = { -1.0, 0.0, 0.0 }; /* Location of planet */

COLOUR colour = { 1.0, 1.0, 0.0 }; /* Yellow */
static int tid = -1; /* Texture id */
if (tid < 0) { /* First time through? */
tid = ss2lt("firetile2_pow2_rgb.tga"); /* Load texture for re-use */
}

static float phase = 30.0; /* Set the texture phase */
XYZ axis = { 0.0, 0.0, 1.0 }; /* Set the rotation axis */
static float rotation = 0.0; /* Set the rotation value */

ns2vplanetx(xyz, radius, colour, tid, phase, axis, rotation);
/* Draw the "planet" */

xyz.x = 0.0; /* Shift centre */
axis.x = 0.0; axis.y = 1.0; axis.z = 0.0; /* New rotation axis */
ns2vplanetx(xyz, radius, colour, tid, phase, axis, rotation);
/* Draw the "planet" */

xyz.x = 1.0; /* Shift centre */
axis.x = 1.0; axis.y = 0.0; axis.z = 0.0; /* New rotation axis */
ns2vplanetx(xyz, radius, colour, tid, phase, axis, rotation);
/* Draw the "planet" */

rotation += 1.0; /* Update rotation in degrees */
if (rotation > 360.0) rotation = 0.0; /* Full circle? Reset */

}

int main(int argc, char *argv[])
{

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */

ss2ssr(32); /* Set the sphere resolution */
cs2scb(cb); /* Install dynamic callback */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2vplanett

2009-01-06T01:49:57Z

Summary:

==ns2vplanett==
Draw a planet with texture filename.

==Prototype==

<code><pre>
void ns2vplanett(XYZ iP, float ir, COLOUR icol, char *itexturefn,float texture_phase, XYZ axis, float rotation);
</pre></code>

==Description==

Draw a planet, which is a textured sphere whose texture can be "slid" around the planet, and the planet then rotated about an arbitrary axis. Texture phase is in the range [0..1], while rotation angle is in degrees.

==See Also==
<table>
<tr><td>[[Function:ns2vplanetx | ns2vplanetx]]</td><td>Draw a planet - vector input.</td></tr>
<tr><td>[[Function:ns2vsphere | ns2vsphere ]]</td><td>Draw a sphere, with a given centre, radius and colour - vector input.</td></tr>
<tr><td>[[Function:ns2spheret | ns2spheret]]</td><td>Draw a textured sphere, with given centre, radius, colour and texture filename </td></tr>
<tr><td>[[Function:ns2vspheret | ns2vspheret]]</td><td>Draw a textured sphere, with given centre, radius, colour and texture filename - vector input.</td></tr>
<tr><td>[[Function:ns2spherex| ns2spherex]]</td><td>Draw a textured sphere, with given centre, radius, colour and texture ID</td></tr>
<tr><td>[[Function:ns2vspherex | ns2vspherex]]</td><td>Draw a textured sphere, with given centre, radius, colour and texture ID - vector input.</td></tr>
<tr><td>[[Function:ns2sphere| ns2sphere]]</td><td>Draw a sphere.</td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

void cb(double *t, int *kc)
{
float radius = 0.5; /* Radius of planet */
XYZ xyz = { -1.0, 0.0, 0.0 }; /* Location of planet */
static char *texture = "firetile2_pow2_rgb.tga"; /* Texture filename */

COLOUR colour = { 1.0, 1.0, 0.0 }; /* Yellow */

static float phase = 30.0; /* Set the texture phase */
XYZ axis = { 0.0, 0.0, 1.0 }; /* Set the rotation axis */
static float rotation = 0.0; /* Set the rotation value */

ns2vplanett(xyz, radius, colour, texture, phase, axis, rotation);
/* Draw the "planet" */

xyz.x = 0.0; /* Shift centre */
axis.x = 0.0; axis.y = 1.0; axis.z = 0.0; /* New rotation axis */
ns2vplanett(xyz, radius, colour, texture, phase, axis, rotation);
/* Draw the "planet" */

xyz.x = 1.0; /* Shift centre */
axis.x = 1.0; axis.y = 0.0; axis.z = 0.0; /* New rotation axis */
ns2vplanett(xyz, radius, colour, texture, phase, axis, rotation);
/* Draw the "planet" */

rotation += 1.0; /* Update rotation in degrees */
if (rotation > 360.0) rotation = 0.0; /* Full circle? Reset */

}

int main(int argc, char *argv[])
{

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */

ss2ssr(32); /* Set the sphere resolution */
cs2scb(cb); /* Install dynamic callback */

s2show(1); /* Open the s2plot window */

return 1;
}
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:ns2vplnett

2009-01-06T01:49:16Z

Summary:

==ns2vplanett==

==Prototype==

<code><pre>
</pre></code>

==Description==

==Code Example==

<code><pre>
</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Back to [[Function:Template | template]] page.

Function:s2help

2009-01-06T01:48:48Z

Summary:

==s2help==
Set the custom help string.

==Prototype==

<code><pre>
void s2help(char *helpstr);
</pre></code>

==Description==
Set the custom help string.This is shown on the 2nd press of the F1 key for S2PLOT programs, if it is set.

==See Also==

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

int main(int argc, char *argv[])
{
s2opend("/?", argc, argv); /* Prompt for display type */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box("BCDET",0,0,"BCDET",0,0,"BCDET",0,0); /* Draw coordinate box */

s2textxy(-1.0, 0.0, 0.0, "Press F1 twice to see custom help");

s2help("This is a custom help message - press F1 again to toggle off!");

s2show(1); /* Open the s2plot window */

return 1;
}

</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:s2wcube

2009-01-06T01:26:30Z

Summary:

==s2wcube==

Draw a wireframe cube.

==Prototype==

<code><pre>
void s2wcube(float xmin, float xmax, float ymin, float ymax, float zmin, float zmax);
</pre></code>

==Description==
Draw a wireframe cube with edges parallel to the main coordinate axes. Thickness and colour controlled by standard S2PLOT functions.

==See Also==
<table>
<tr><td>[[Function:ns2scube | ns2scube ]]</td><td>Draw a solid cube.</td></tr>
<tr><td>[[Function:ns2vscube |ns2vscube ]]</td><td>Draw a solid cube - vector input. </td></tr>
<tr><td>[[Function:ns2thwcube | ns2thwcube ]]</td><td>Draw a wireframe cube. </td></tr>
<tr><td>[[Function:ns2vthwcube | ns2vthwcube ]]</td><td>Draw a wireframe cube - vector input. </td></tr>
</table>

==Code Example==

<code><pre>
#include <stdio.h>
#include <stdlib.h>
#include "s2plot.h"

int main(int argc, char *argv[])
{
char xopt[] = "BCDETMNOPQ";
char yopt[] = "BCDETMNOPQ";
char zopt[] = "BCDETMNOPQ";

s2opend("/?",argc, argv); /* Open the display */
s2swin(-1.,1., -1.,1., -1.,1.); /* Set the window coordinates */
s2box(xopt, 0,0, yopt, 0,0, zopt, 0,0); /* Draw the coordinate box */
s2lab("X-axis","Y-axis","Z-axis","Plot"); /* Write some labels */

float x1 = -0.8, x2 = +0.8; /* Box coordinates */
float y1 = -0.8, y2 = +0.8;
float z1 = -0.8, z2 = +0.8;

s2sci(S2_PG_RED);

s2wcube(x1,x2, y1,y2, z1,z2);

s2show(1); /* Open the s2plot window */

return 0;
}

</pre></code>

[[S2PLOT:Function List | Back]] to S2PLOT function list.

__NOTOC__
__NOEDITSECTION__

Function:template

2009-01-06T01:25:24Z

Summary:

==Template==

Link

[[Function:s2wcube | s2wcube]]

Back to [[Function:Template | template]] page.