Loading...
Searching...
No Matches
gs2.c
Go to the documentation of this file.
/*!
\file lib/ogsf/gs2.c
\brief OGSF library - loading and manipulating surfaces (higher level
functions)
GRASS OpenGL gsurf OGSF Library
Plans for handling color maps:
NOW:
if able to load as unsigned char, make lookup table containing palette
otherwise, load directly as packed color, set lookup = NULL
MAYBE LATER:
if able to load as POSITIVE short, make lookup table containing palette
- may want to calculate savings first (ie, numcells > 32768)
(not exactly, it's Friday & time to go home - figure it later)
otherwise, load directly as packed color, set lookup = NULL
MESSY! - need to fix up!
(C) 1999-2008 by the GRASS Development Team
This program is free software under the
GNU General Public License (>=v2).
Read the file COPYING that comes with GRASS
for details.
\author Bill Brown USACERL (1993)
\author Pierre de Mouveaux <p_de_mouveaux hotmail.com> (updated October 1999)
\author Doxygenized by Martin Landa <landa.martin gmail.com> (May 2008)
*/
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <grass/config.h>
#if defined(OPENGL_X11) || defined(OPENGL_WINDOWS)
#include <GL/gl.h>
#include <GL/glu.h>
#elif defined(OPENGL_AQUA)
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#endif
#include <grass/gis.h>
#include <grass/raster.h>
#include <grass/ogsf.h>
#include <grass/glocale.h>
#include "gsget.h"
#include "rowcol.h"
#include "rgbpack.h"
/* Hack to make NVIZ2.2 query functions.("What's Here" and "Look at")
* to work.
* Uses gs_los_intersect1() instead of gs_los_intersect().
* Pierre de Mouveaux - 31 oct. 1999. p_de_mouveaux@hotmail.com.
*/
#define NVIZ_HACK 1
int gsd_getViewport(GLint *, GLint *);
/* array of surface ids */
static int Surf_ID[MAX_SURFS];
static int Next_surf = 0;
static int SDref_surf = 0;
/* attributes array */
static float Default_const[MAX_ATTS];
static float Default_nulls[MAX_ATTS];
/* largest dimension */
static float Longdim;
/* N, S, W, E */
static float Region[4];
static geoview Gv;
static geodisplay Gd;
static struct Cell_head wind;
static int Buffermode;
static int Numlights = 0;
static int Resetlight = 1;
static int Modelshowing = 0;
void void_func(void)
{
return;
}
/*!
\brief Initialize OGSF library
Get region settings - wind
Set Region (NSWE array) and compute scale
*/
void GS_libinit(void)
{
static int first = 1;
G_get_set_window(&wind);
Region[0] = wind.north;
Region[1] = wind.south;
Region[2] = wind.west;
Region[3] = wind.east;
/* scale largest dimension to GS_UNIT_SIZE */
if ((wind.east - wind.west) > (wind.north - wind.south)) {
Longdim = (wind.east - wind.west);
}
else {
Longdim = (wind.north - wind.south);
}
Gv.scale = GS_UNIT_SIZE / Longdim;
G_debug(1, "GS_libinit(): n=%f s=%f w=%f e=%f scale=%f first=%d", Region[0],
Region[1], Region[2], Region[3], Gv.scale, first);
Cxl_func = void_func;
if (first) {
gs_init();
}
first = 0;
return;
}
/*!
\brief Get largest dimension
\param[out] dim dimension
\return 1
*/
int GS_get_longdim(float *dim)
{
*dim = Longdim;
G_debug(3, "GS_get_longdim(): dim=%g", *dim);
return (1);
}
/*!
\brief Get 2D region extent
\param[out] n,s,w,e extent values
\return 1
*/
int GS_get_region(float *n, float *s, float *w, float *e)
{
*n = Region[0];
*s = Region[1];
*w = Region[2];
*e = Region[3];
return (1);
}
/*!
\brief Set default attributes for map objects
\param defs attributes array (dim MAX_ATTS)
\param null_defs null attributes array (dim MAX_ATTS)
*/
void GS_set_att_defaults(float *defs, float *null_defs)
{
int i;
G_debug(3, "GS_set_att_defaults");
for (i = 0; i < MAX_ATTS; i++) {
Default_const[i] = defs[i];
Default_nulls[i] = null_defs[i];
}
return;
}
/*!
Check if surface exists
\param id surface id
\return 0 not found
\return 1 found
*/
int GS_surf_exists(int id)
{
int i, found = 0;
G_debug(3, "GS_surf_exists(): id=%d", id);
if (NULL == gs_get_surf(id)) {
return (0);
}
for (i = 0; i < Next_surf && !found; i++) {
if (Surf_ID[i] == id) {
found = 1;
}
}
return (found);
}
/*!
\brief Add new surface
Note that origin has 1/2 cell added to represent center of cells
because library assumes that east - west = (cols - 1) * ew_res,
since left and right columns are on the edges.
\return surface id
\return -1 on error (MAX_SURFS exceeded)
*/
int GS_new_surface(void)
{
geosurf *ns;
G_debug(3, "GS_new_surface():");
if (Next_surf < MAX_SURFS) {
ns = gs_get_new_surface();
gs_init_surf(ns, wind.west + wind.ew_res / 2.,
wind.south + wind.ns_res / 2., wind.rows, wind.cols,
wind.ew_res, wind.ns_res);
gs_set_defaults(ns, Default_const, Default_nulls);
/* make default shine current */
gs_set_att_src(ns, ATT_SHINE, CONST_ATT);
Surf_ID[Next_surf] = ns->gsurf_id;
++Next_surf;
G_debug(3, " id=%d", ns->gsurf_id);
return (ns->gsurf_id);
}
return (-1);
}
void GS_set_light_reset(int i)
{
Resetlight = i;
if (i)
Numlights = 0;
}
int GS_get_light_reset(void)
{
return Resetlight;
}
/*!
\brief Add new model light
\return light model id
\return -1 on error (MAX_LIGHTS exceeded)
*/
int GS_new_light(void)
{
int i;
if (GS_get_light_reset()) {
GS_set_light_reset(0);
for (i = 0; i < MAX_LIGHTS; i++) {
Gv.lights[i].position[X] = Gv.lights[i].position[Y] = 0.0;
Gv.lights[i].position[Z] = 1.0;
Gv.lights[i].position[W] = 0.0; /* infinite */
Gv.lights[i].color[0] = Gv.lights[i].color[1] =
Gv.lights[i].color[2] = 1.0;
Gv.lights[i].ambient[0] = Gv.lights[i].ambient[1] =
Gv.lights[i].ambient[2] = 0.2;
Gv.lights[i].shine = 32.0;
}
gsd_init_lightmodel();
}
if (Numlights < MAX_LIGHTS) {
gsd_deflight(Numlights + 1, &(Gv.lights[Numlights]));
gsd_switchlight(Numlights + 1, 1);
return ++Numlights;
}
return -1;
}
/*!
\brief Set light position
\bug I think lights array doesn't match sgi_light array
\param num light id (starts with 1)
\param xpos,ypos,zpos coordinates (model)
\param local local coordinate (for viewport)
*/
void GS_setlight_position(int num, float xpos, float ypos, float zpos,
int local)
{
if (num) {
num -= 1;
if (num < Numlights) {
Gv.lights[num].position[X] = xpos;
Gv.lights[num].position[Y] = ypos;
Gv.lights[num].position[Z] = zpos;
Gv.lights[num].position[W] = (float)local;
gsd_deflight(num + 1, &(Gv.lights[num]));
}
}
return;
}
/*!
\brief Get light position
\param num light id (starts at 1)
\param[out] xpos,ypos,zpos coordinates
\param[out] local ?
*/
void GS_getlight_position(int num, float *xpos, float *ypos, float *zpos,
int *local)
{
if (num) {
num -= 1;
if (num < Numlights) {
*xpos = Gv.lights[num].position[X];
*ypos = Gv.lights[num].position[Y];
*zpos = Gv.lights[num].position[Z];
*local = (int)Gv.lights[num].position[W];
}
}
return;
}
/*!
\brief Set light color
\param num light id (starts at 1)
\param red,green,blue color values (from 0.0 to 1.0)
*/
void GS_setlight_color(int num, float red, float green, float blue)
{
if (num) {
num -= 1;
if (num < Numlights) {
Gv.lights[num].color[0] = red;
Gv.lights[num].color[1] = green;
Gv.lights[num].color[2] = blue;
gsd_deflight(num + 1, &(Gv.lights[num]));
}
}
return;
}
/*!
\brief Get light color
\param num light id (starts at 1)
\param[out] red,green,blue color values
*/
void GS_getlight_color(int num, float *red, float *green, float *blue)
{
if (num) {
num -= 1;
if (num < Numlights) {
*red = Gv.lights[num].color[0];
*green = Gv.lights[num].color[1];
*blue = Gv.lights[num].color[2];
}
}
return;
}
/*!
\brief Set light ambient
Red, green, blue from 0.0 to 1.0
\param num light id (starts at 1)
\param red,green,blue color values
*/
void GS_setlight_ambient(int num, float red, float green, float blue)
{
if (num) {
num -= 1;
if (num < Numlights) {
Gv.lights[num].ambient[0] = red;
Gv.lights[num].ambient[1] = green;
Gv.lights[num].ambient[2] = blue;
gsd_deflight(num + 1, &(Gv.lights[num]));
}
}
return;
}
/*!
\brief Get light ambient
\param num light id (starts at 1)
\param[out] red,green,blue color values
*/
void GS_getlight_ambient(int num, float *red, float *green, float *blue)
{
if (num) {
num -= 1;
if (num < Numlights) {
*red = Gv.lights[num].ambient[0];
*green = Gv.lights[num].ambient[1];
*blue = Gv.lights[num].ambient[2];
}
}
return;
}
/*!
\brief Switch off all lights
*/
void GS_lights_off(void)
{
int i;
for (i = 0; i < Numlights; i++) {
gsd_switchlight(i + 1, 0);
}
return;
}
/*!
\brief Switch on all lights
*/
void GS_lights_on(void)
{
int i;
for (i = 0; i < Numlights; i++) {
gsd_switchlight(i + 1, 1);
}
return;
}
/*!
\brief Switch on/off light
\param num light id (starts at 1)
\param on non-zero for 'on' otherwise 'off'
*/
void GS_switchlight(int num, int on)
{
if (num) {
num -= 1;
if (num < Numlights) {
gsd_switchlight(num + 1, on);
}
}
return;
}
/*!
\brief Check if transparency is set
\return 0 transparency not set
\return 1 transparency is set
*/
int GS_transp_is_set(void)
{
return (gs_att_is_set(NULL, ATT_TRANSP) || (FC_GREY == gsd_getfc()));
}
/*!
\brief Retrieves coordinates for lighting model position, at center of view
\param[out] pos coordinates
*/
void GS_get_modelposition1(float pos[])
{
/* TODO: Still needs work to handle other cases */
/* this is a quick hack to get lighting adjustments debugged */
/*
GS_v3dir(Gv.from_to[FROM], Gv.from_to[TO], center);
GS_v3mult(center, 1000);
GS_v3add(center, Gv.from_to[FROM]);
*/
gs_get_datacenter(pos);
gs_get_data_avg_zmax(&(pos[Z]));
G_debug(1, "GS_get_modelposition1(): model position: %f %f %f", pos[X],
pos[Y], pos[Z]);
return;
}
/*!
\brief Retrieves coordinates for lighting model position, at center of view
Position at nearclip * 2: tried nearclip + siz, but since need to
know position to calculate size, have two dependent variables
(nearclip * 2) from eye.
\param[out] size size
\param[out] pos coordinates (X, Y, Z)
*/
void GS_get_modelposition(float *size, float *pos)
{
float dist, near_h, dir[3];
dist = 2. * Gd.nearclip;
near_h = 2.0 * tan(4.0 * atan(1.) * Gv.fov / 3600.) * dist;
*size = near_h / 8.0;
/* prevent clipping - would only happen if fov > ~127 degrees, at
fov = 2.0 * atan(2.0) */
if (*size > Gd.nearclip) {
*size = Gd.nearclip;
}
GS_v3dir(Gv.from_to[FROM], Gv.from_to[TO], dir);
pos[X] = Gv.from_to[FROM][X] + dir[X] * dist;
pos[Y] = Gv.from_to[FROM][Y] + dir[Y] * dist;
pos[Z] = Gv.from_to[FROM][Z] + dir[Z] * dist;
return;
}
/*!
\brief Set decoration, north arrow ??
\todo scale used to calculate len of arrow still needs work
needs go function that returns center / eye distance
gsd_get_los function is not working correctly ??
\param pt point value in true world coordinates (?)
\param id surface id
\param[out] pos2 output coordinates
*/
void GS_set_Narrow(int *pt, int id, float *pos2)
{
geosurf *gs;
float x, y, z;
GLdouble modelMatrix[16], projMatrix[16];
GLint viewport[4];
if (GS_get_selected_point_on_surface(pt[X], pt[Y], &id, &x, &y, &z)) {
gs = gs_get_surf(id);
if (gs) {
z = gs->zmax;
pos2[X] = (float)x - gs->ox + gs->x_trans;
pos2[Y] = (float)y - gs->oy + gs->y_trans;
pos2[Z] = (float)z + gs->z_trans;
return;
}
}
else {
gs = gs_get_surf(id);
/* Need to get model matrix, etc
* to run gluUnProject
*/
gsd_pushmatrix();
gsd_do_scale(1);
glGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
glGetIntegerv(GL_VIEWPORT, viewport);
if (gs) {
GLdouble out_near[3], out_far[3];
GLdouble factor;
GLdouble out[3];
z = (float)gs->zmax + gs->z_trans;
gluUnProject((GLdouble)pt[X], (GLdouble)pt[Y], (GLdouble)0.,
modelMatrix, projMatrix, viewport, &out_near[X],
&out_near[Y], &out_near[Z]);
gluUnProject((GLdouble)pt[X], (GLdouble)pt[Y], (GLdouble)1.,
modelMatrix, projMatrix, viewport, &out_far[X],
&out_far[Y], &out_far[Z]);
glPopMatrix();
factor = (out_near[Z] - z) / (out_near[Z] - out_far[Z]);
out[X] = out_near[X] - ((out_near[X] - out_far[X]) * factor);
out[Y] = out_near[Y] - ((out_near[Y] - out_far[Y]) * factor);
out[Z] = z;
pos2[X] = (float)out[X];
pos2[Y] = (float)out[Y];
pos2[Z] = (float)out[Z];
return;
}
}
return;
}
/*!
\brief Draw place marker
Used to display query point for raster queries.
\param id surface id
\param pt point, X, Y value in true world coordinates
*/
void GS_draw_X(int id, float *pt)
{
geosurf *gs;
Point3 pos;
float siz;
gvstyle style;
if ((gs = gs_get_surf(id))) {
GS_get_longdim(&siz);
style.size = siz / 200.;
pos[X] = pt[X] - gs->ox;
pos[Y] = pt[Y] - gs->oy;
_viewcell_tri_interp(gs, pos);
gsd_pushmatrix();
gsd_do_scale(1);
gsd_translate(gs->x_trans, gs->y_trans, gs->z_trans);
gsd_linewidth(1);
if (CONST_ATT == gs_get_att_src(gs, ATT_TOPO)) {
pos[Z] = gs->att[ATT_TOPO].constant;
gs = NULL; /* tells gpd_obj to use given Z val */
}
style.color = Gd.bgcol;
style.symbol = ST_GYRO;
gpd_obj(gs, &style, pos);
gsd_flush();
gsd_popmatrix();
}
return;
}
/*!
\brief Draw line on surface
\param id surface id
\param x1,y1,x2,y2 line nodes
*/
void GS_draw_line_onsurf(int id, float x1, float y1, float x2, float y2)
{
float p1[2], p2[2];
geosurf *gs;
if ((gs = gs_get_surf(id))) {
p1[X] = x1 - gs->ox;
p1[Y] = y1 - gs->oy;
p2[X] = x2 - gs->ox;
p2[Y] = y2 - gs->oy;
gsd_pushmatrix();
gsd_do_scale(1);
gsd_translate(gs->x_trans, gs->y_trans, gs->z_trans);
gsd_linewidth(1);
gsd_color_func(GS_default_draw_color());
gsd_line_onsurf(gs, p1, p2);
gsd_popmatrix();
gsd_flush();
}
return;
}
/*!
\brief Draw multiline on surface
Like above but limits points in line to n or points found in segment,
whichever is smaller.
\param id surface id
\param x1,y1,x2,y2 line nodes
\param lasp
\param n
\return number of points used
*/
int GS_draw_nline_onsurf(int id, float x1, float y1, float x2, float y2,
float *lasp, int n)
{
float p1[2], p2[2];
geosurf *gs;
int ret = 0;
if ((gs = gs_get_surf(id))) {
p1[X] = x1 - gs->ox;
p1[Y] = y1 - gs->oy;
p2[X] = x2 - gs->ox;
p2[Y] = y2 - gs->oy;
gsd_pushmatrix();
gsd_do_scale(1);
gsd_translate(gs->x_trans, gs->y_trans, gs->z_trans);
gsd_linewidth(1);
gsd_color_func(GS_default_draw_color());
ret = gsd_nline_onsurf(gs, p1, p2, lasp, n);
gsd_surf2real(gs, lasp);
gsd_popmatrix();
gsd_flush();
}
return (ret);
}
/*!
\brief Draw flow-line on surace
This is slow - should be moved to gs_ but GS_ good for testing
and useful for app programmer
\param id surface id
\param x,y coordinates of flow-line
*/
void GS_draw_flowline_at_xy(int id, float x, float y)
{
geosurf *gs;
float nv[3], pdir[2], mult;
float p1[2], p2[2], next[2];
int i = 0;
if ((gs = gs_get_surf(id))) {
p1[X] = x;
p1[Y] = y;
/* multiply by 1.5 resolutions to ensure a crossing ? */
mult = .1 * (VXRES(gs) > VYRES(gs) ? VXRES(gs) : VYRES(gs));
GS_coordpair_repeats(p1, p1, 50);
while (1 == GS_get_norm_at_xy(id, p1[X], p1[Y], nv)) {
if (nv[Z] == 1.0) {
if (pdir[X] == 0.0 && pdir[Y] == 0.0) {
break;
}
p2[X] = p1[X] + (pdir[X] * mult);
p2[Y] = p1[Y] + (pdir[Y] * mult);
}
else {
/* use previous direction */
GS_v2norm(nv);
p2[X] = p1[X] + (nv[X] * mult);
p2[Y] = p1[Y] + (nv[Y] * mult);
pdir[X] = nv[X];
pdir[Y] = nv[Y];
}
if (i > 2000) {
break;
}
if (GS_coordpair_repeats(p1, p2, 0)) {
break;
}
/* Think about this: */
/* degenerate line means edge or level edge ? */
/* next is filled with last point drawn */
if (2 >
GS_draw_nline_onsurf(id, p1[X], p1[Y], p2[X], p2[Y], next, 3)) {
break;
}
p1[X] = next[X];
p1[Y] = next[Y];
}
G_debug(3, "GS_draw_flowline_at_xy(): dir: %f %f", nv[X], nv[Y]);
}
return;
}
/*!
\brief Draw fringe around data (surface) at selected corners
\param id surface id
\param clr color
\param elev elevation value
\param where nw/ne/sw/se edges - 0 (turn off) 1 (turn on)
*/
void GS_draw_fringe(int id, unsigned long clr, float elev, int *where)
{
geosurf *gs;
G_debug(3, "GS_draw_fringe(): id: %d clr: %ld elev %f edges: %d %d %d %d",
id, clr, elev, where[0], where[1], where[2], where[3]);
if ((gs = gs_get_surf(id)))
gsd_display_fringe(gs, clr, elev, where);
}
/*!
\brief Draw legend
\todo add legend from list option
make font loading more flexible
\param name legend name
\param fontbase font-base
\param size ?
\param flags legend flags
\param range values range
\param pt ?
*/
int GS_draw_legend(const char *name, GLuint fontbase, int size, int *flags,
float *range, int *pt)
{
int list_no;
list_no = gsd_put_legend(name, fontbase, size, flags, range, pt);
return (list_no);
}
/*!
\brief Draw pre-defined list
Uses glFlush() to ensure all drawing is complete
before returning
\param list_id list id
*/
void GS_draw_list(GLuint list_id)
{
gsd_calllist(list_id);
glFlush();
return;
}
/*!
\brief Draw all glLists
Uses glFlush() to ensure all drawing is complete
before returning
*/
void GS_draw_all_list(void)
{
gsd_calllists(0); /* not sure if 0 is right - MN */
glFlush();
return;
}
/*!
\brief Delete pre-defined list
\param list_id list id
*/
void GS_delete_list(GLuint list_id)
{
gsd_deletelist(list_id, 1);
return;
}
/*!
\brief Draw lighting model
*/
void GS_draw_lighting_model1(void)
{
static float center[3];
float tcenter[3];
if (!Modelshowing) {
GS_get_modelposition1(center);
}
GS_v3eq(tcenter, center);
gsd_zwritemask(0x0);
gsd_backface(1);
gsd_colormode(CM_AD);
gsd_shademodel(DM_GOURAUD);
gsd_pushmatrix();
gsd_do_scale(1);
if (Gv.vert_exag) {
tcenter[Z] *= Gv.vert_exag;
gsd_scale(1.0, 1.0, 1. / Gv.vert_exag);
}
gsd_drawsphere(tcenter, 0xDDDDDD, (float)(Longdim / 10.));
gsd_popmatrix();
Modelshowing = 1;
gsd_backface(0);
gsd_zwritemask(0xffffffff);
return;
}
/*!
\brief Draw lighting model
Just turn off any cutting planes and draw it just outside near
clipping plane, since lighting is infinite now
*/
void GS_draw_lighting_model(void)
{
static float center[3], size;
float tcenter[3], tsize;
int i, wason[MAX_CPLANES];
gsd_get_cplanes_state(wason);
for (i = 0; i < MAX_CPLANES; i++) {
if (wason[i]) {
gsd_cplane_off(i);
}
}
if (!Modelshowing) {
GS_get_modelposition(&size, center);
}
GS_v3eq(tcenter, center);
tsize = size;
gsd_zwritemask(0x0);
gsd_backface(1);
gsd_colormode(CM_DIFFUSE);
gsd_shademodel(DM_GOURAUD);
gsd_pushmatrix();
gsd_drawsphere(tcenter, 0xDDDDDD, tsize);
gsd_popmatrix();
Modelshowing = 1;
gsd_backface(0);
gsd_zwritemask(0xffffffff);
for (i = 0; i < MAX_CPLANES; i++) {
if (wason[i]) {
gsd_cplane_on(i);
}
}
gsd_flush();
return;
}
/*!
\brief Update current mask
May be called to update total mask for a surface at convenient times
instead of waiting until ready to redraw surface
\param id surface id
\return ?
*/
int GS_update_curmask(int id)
{
geosurf *gs;
gs = gs_get_surf(id);
return (gs_update_curmask(gs));
}
/*!
\brief Check if point is masked ?
\param id surface id
\param pt point
\return 1 masked
\return 0 not masked
\return -1 on error, invalid surface id
*/
int GS_is_masked(int id, float *pt)
{
geosurf *gs;
Point3 tmp;
if ((gs = gs_get_surf(id))) {
tmp[X] = pt[X] - gs->ox;
tmp[Y] = pt[Y] - gs->oy;
return (gs_point_is_masked(gs, tmp));
}
return (-1);
}
/*!
\brief Unset Scaled Difference surface
*/
void GS_unset_SDsurf(void)
{
gsdiff_set_SDref(NULL);
SDref_surf = 0;
return;
}
/*!
\brief Set surface as Scaled Difference surface
\param id surface id
\return 1 on success
\return 0 on error, invalid surface id
*/
int GS_set_SDsurf(int id)
{
geosurf *gs;
if ((gs = gs_get_surf(id))) {
gsdiff_set_SDref(gs);
SDref_surf = id;
return (1);
}
return (0);
}
/*!
\brief Set ?
\param scale scale value
\return 1
*/
int GS_set_SDscale(float scale)
{
gsdiff_set_SDscale(scale);
return (1);
}
/*!
\brief Get ?
\param[out] id ?
\return 1 on success
\return 0 on error
*/
int GS_get_SDsurf(int *id)
{
geosurf *gs;
if ((gs = gsdiff_get_SDref())) {
*id = SDref_surf;
return (1);
}
return (0);
}
/*!
\brief Get ?
\param[out] scale value
\return 1
*/
int GS_get_SDscale(float *scale)
{
*scale = gsdiff_get_SDscale();
return (1);
}
/*!
\brief Update normals
\param id surface id
\return ?
*/
int GS_update_normals(int id)
{
geosurf *gs;
gs = gs_get_surf(id);
return (gs_calc_normals(gs));
}
/*!
\brief Get attributes
\param id surface id
\param att
\param[out] set
\param[out] constant
\param[out] mapname
\return 1 on success
\return -1 on error (invalid surface id)
*/
int GS_get_att(int id, int att, int *set, float *constant, char *mapname)
{
int src;
geosurf *gs;
gs = gs_get_surf(id);
if (gs) {
if (-1 != (src = gs_get_att_src(gs, att))) {
*set = src;
if (src == CONST_ATT) {
*constant = gs->att[att].constant;
}
else if (src == MAP_ATT) {
strcpy(mapname, gsds_get_name(gs->att[att].hdata));
}
return (1);
}
return (-1);
}
return (-1);
}
/*!
\brief Get surface category on given position
Prints "no data" or a description (i.e., "coniferous forest") to
<i>catstr</i>. Usually call after GS_get_selected_point_on_surface().
Define <i>att</i> as MAP_ATT
\todo Allocate catstr using G_store()
\param id surface id
\param att attribute id (MAP_ATT)
\param catstr cat string (must be allocated, dim?)
\param x,y real coordinates
\return -1 if no category info or point outside of window
\return 1 on success
*/
int GS_get_cat_at_xy(int id, int att, char *catstr, float x, float y)
{
int offset, drow, dcol, vrow, vcol;
float ftmp, pt[3];
typbuff *buff;
geosurf *gs;
*catstr = '\0';
gs = gs_get_surf(id);
if (NULL == gs) {
return -1;
}
pt[X] = x;
pt[Y] = y;
gsd_real2surf(gs, pt);
if (gs_point_is_masked(gs, pt)) {
return -1;
}
if (!in_vregion(gs, pt)) {
return -1;
}
if (MAP_ATT != gs_get_att_src(gs, att)) {
sprintf(catstr, _("no category info"));
return -1;
}
buff = gs_get_att_typbuff(gs, att, 0);
vrow = Y2VROW(gs, pt[Y]);
vcol = X2VCOL(gs, pt[X]);
drow = VROW2DROW(gs, vrow);
dcol = VCOL2DCOL(gs, vcol);
offset = DRC2OFF(gs, drow, dcol);
if (GET_MAPATT(buff, offset, ftmp)) {
return (Gs_get_cat_label(gsds_get_name(gs->att[att].hdata), drow, dcol,
catstr));
}
sprintf(catstr, _("no data"));
return 1;
}
/*!
\brief Get surface normal at x,y (real coordinates)
Usually call after GS_get_selected_point_on_surface()
\param id surface id
\param x,y real coordinates
\param[out] nv surface normal
\return -1 if point outside of window or masked
\return 1 on success
*/
int GS_get_norm_at_xy(int id, float x, float y, float *nv)
{
int offset, drow, dcol, vrow, vcol;
float pt[3];
geosurf *gs;
gs = gs_get_surf(id);
if (NULL == gs) {
return (-1);
}
if (gs->norm_needupdate) {
gs_calc_normals(gs);
}
pt[X] = x;
pt[Y] = y;
gsd_real2surf(gs, pt);
if (gs_point_is_masked(gs, pt)) {
return (-1);
}
if (!in_vregion(gs, pt)) {
return (-1);
}
vrow = Y2VROW(gs, pt[Y]);
vcol = X2VCOL(gs, pt[X]);
drow = VROW2DROW(gs, vrow);
dcol = VCOL2DCOL(gs, vcol);
offset = DRC2OFF(gs, drow, dcol);
if (gs->norms) {
FNORM(gs->norms[offset], nv);
}
else {
/* otherwise must be a constant */
nv[0] = 0.0;
nv[1] = 0.0;
nv[2] = 1.0;
}
return (1);
}
/*!
\brief Get RGB color at given point
Colors are translated to rgb and returned as Rxxx Gxxx Bxxx Usually
call after GS_get_selected_point_on_surface().
Prints NULL or the value (i.e., "921.5") to valstr
\param id surface id
\param att attribute id
\param[out] valstr value string (allocated, dim?)
\param x,y real coordinates
\return -1 if point outside of window or masked
\return 1 on success
*/
int GS_get_val_at_xy(int id, int att, char *valstr, float x, float y)
{
int offset, drow, dcol, vrow, vcol;
float ftmp, pt[3];
typbuff *buff;
geosurf *gs;
*valstr = '\0';
gs = gs_get_surf(id);
if (NULL == gs) {
return -1;
}
pt[X] = x;
pt[Y] = y;
gsd_real2surf(gs, pt);
if (gs_point_is_masked(gs, pt)) {
return -1;
}
if (!in_vregion(gs, pt)) {
return (-1);
}
if (CONST_ATT == gs_get_att_src(gs, att)) {
if (att == ATT_COLOR) {
int r, g, b, i;
i = gs->att[att].constant;
sprintf(valstr, "R%d G%d B%d", INT_TO_RED(i, r), INT_TO_GRN(i, g),
INT_TO_BLU(i, b));
}
else {
sprintf(valstr, "%f", gs->att[att].constant);
}
return 1;
}
else if (MAP_ATT != gs_get_att_src(gs, att)) {
return -1;
}
buff = gs_get_att_typbuff(gs, att, 0);
vrow = Y2VROW(gs, pt[Y]);
vcol = X2VCOL(gs, pt[X]);
drow = VROW2DROW(gs, vrow);
dcol = VCOL2DCOL(gs, vcol);
offset = DRC2OFF(gs, drow, dcol);
if (GET_MAPATT(buff, offset, ftmp)) {
if (att == ATT_COLOR) {
int r, g, b, i;
i = gs_mapcolor(gs_get_att_typbuff(gs, ATT_COLOR, 0),
&(gs->att[ATT_COLOR]), offset);
sprintf(valstr, "R%d G%d B%d", INT_TO_RED(i, r), INT_TO_GRN(i, g),
INT_TO_BLU(i, b));
}
else {
sprintf(valstr, "%f", ftmp);
}
return (1);
}
sprintf(valstr, "NULL");
return (1);
}
/*!
\brief Unset attribute
\param id surface id
\param att attribute id
\return ?
*/
int GS_unset_att(int id, int att)
{
geosurf *gs;
gs = gs_get_surf(id);
gs->mask_needupdate = 1;
return (gs_set_att_src(gs, att, NOTSET_ATT));
}
/*!
\brief Set attribute constant
\param id surface id
\param att attribute id
\param constant value
\return ?
*/
int GS_set_att_const(int id, int att, float constant)
{
geosurf *gs;
int ret;
gs = gs_get_surf(id);
ret = (gs_set_att_const(gs, att, constant));
Gs_update_attrange(gs, att);
return (ret);
}
/*!
\brief Set mask mode
Mask attribute special: constant is set to indicate invert or no
\param id surface id
\param mode id
\return mode id
\return -1 on error (invalid surface id)
*/
int GS_set_maskmode(int id, int mode)
{
geosurf *gs;
gs = gs_get_surf(id);
if (gs) {
gs->att[ATT_MASK].constant = mode;
gs->mask_needupdate = 1;
return (mode);
}
return (-1);
}
/*!
\brief Get mask mode
\param id surface id
\param[out] mode id
\return 1 on success
\return -1 on error (invalid surface id)
*/
int GS_get_maskmode(int id, int *mode)
{
geosurf *gs;
gs = gs_get_surf(id);
if (gs) {
*mode = gs->att[ATT_MASK].constant;
return (1);
}
return (-1);
}
/*!
\brief Set client data
\param id surface id
\param clientd pointer to client data struct
\return 1 on success
\return -1 on error (invalid surface id)
*/
int GS_Set_ClientData(int id, void *clientd)
{
geosurf *gs;
gs = gs_get_surf(id);
if (gs) {
gs->clientdata = clientd;
return (1);
}
return (-1);
}
/*!
\brief Get client data
\param id surface id
\return pointer to client data
\return NULL on error
*/
void *GS_Get_ClientData(int id)
{
geosurf *gs;
gs = gs_get_surf(id);
if (gs) {
return (gs->clientdata);
}
return (NULL);
}
/*!
\brief Get number of surfaces
\return number of surfaces
*/
int GS_num_surfs(void)
{
return (gs_num_surfaces());
}
/*!
\brief Get surface list
Must be freed when not needed!
\param[out] numsurfs number of available surfaces
\return pointer to surface array
\return NULL on error
*/
int *GS_get_surf_list(int *numsurfs)
{
int i, *ret;
*numsurfs = Next_surf;
if (Next_surf) {
ret = (int *)G_malloc(Next_surf * sizeof(int));
for (i = 0; i < Next_surf; i++) {
ret[i] = Surf_ID[i];
}
return (ret);
}
return (NULL);
}
/*!
\brief Delete surface
\param id surface id
\return 1 on success
\return -1 on error
*/
int GS_delete_surface(int id)
{
int i, j, found;
found = FALSE;
G_debug(1, "GS_delete_surface(): id=%d", id);
if (GS_surf_exists(id)) {
gs_delete_surf(id);
for (i = 0; i < Next_surf && !found; i++) {
if (Surf_ID[i] == id) {
found = TRUE;
for (j = i; j < Next_surf; j++) {
Surf_ID[j] = Surf_ID[j + 1];
}
}
}
gv_update_drapesurfs();
if (found) {
--Next_surf;
return 1;
}
}
return -1;
}
/*!
\brief Load raster map as attribute
\param id surface id
\param filename filename
\param att attribute descriptor
\return -1 on error (invalid surface id)
\return ?
*/
int GS_load_att_map(int id, const char *filename, int att)
{
geosurf *gs;
unsigned int changed;
unsigned int atty;
const char *mapset;
struct Cell_head rast_head;
int reuse, begin, hdata, ret, neg, has_null;
typbuff *tbuff;
G_debug(3, "GS_load_att_map(): map=%s", filename);
reuse = ret = neg = has_null = 0;
gs = gs_get_surf(id);
if (NULL == gs) {
return -1;
}
gs->mask_needupdate = (ATT_MASK == att || ATT_TOPO == att ||
(gs->nz_topo && ATT_TOPO == att) ||
(gs->nz_color && ATT_COLOR == att));
gs_set_att_src(gs, att, MAP_ATT);
/* Check against maps already loaded in memory */
/* if to be color attribute:
- if packed color for another surface, OK to reuse
- if unchanged, ok to reuse IF it's of type char (will have lookup)
*/
begin = hdata = 1;
/* Get MAPSET to ensure names are fully qualified */
mapset = G_find_raster2(filename, "");
if (mapset == NULL) {
/* Check for valid filename */
G_warning("Raster map <%s> not found", filename);
return -1;
}
/* Check to see if map is in Region */
Rast_get_cellhd(filename, mapset, &rast_head);
if (rast_head.north <= wind.south || rast_head.south >= wind.north ||
rast_head.east <= wind.west || rast_head.west >= wind.east) {
char *mname = G_fully_qualified_name(filename, mapset);
G_warning(
_("Raster map <%s> is outside of current region. Load failed."),
mname);
G_free(mname);
}
while (!reuse && (0 < hdata)) {
changed = CF_COLOR_PACKED;
atty = ATTY_FLOAT | ATTY_CHAR | ATTY_INT | ATTY_SHORT | ATTY_MASK;
if (0 < (hdata = gsds_findh(filename, &changed, &atty, begin))) {
G_debug(3, "GS_load_att_map(): %s already has data handle %d.CF=%x",
filename, hdata, changed);
/* handle found */
if (ATT_COLOR == att) {
if ((changed == CF_COLOR_PACKED) ||
(!changed && atty == ATTY_CHAR)) {
reuse = 1;
}
}
else if (atty == ATTY_MASK && att != ATT_MASK) {
reuse = 0;
/* should also free mask data & share new - but need backward
reference? */
}
else if (!changed) {
reuse = 1;
}
}
begin = 0;
}
if (reuse) {
gs->att[att].hdata = hdata;
gs_set_att_type(gs, att, atty); /* ?? */
/* free lookup & set to NULL! */
if (atty == ATTY_INT) {
if (gs->att[att].lookup) {
free(gs->att[att].lookup);
gs->att[att].lookup = NULL;
}
}
/* TODO: FIX THIS stuff with lookup sharing! */
G_debug(3, "GS_load_att_map(): %s is being reused. hdata=%d", filename,
hdata);
}
else {
G_debug(
3, "GS_load_att_map(): %s not loaded in correct form - loading now",
filename);
/* not loaded - need to get new dataset handle */
gs->att[att].hdata = gsds_newh(filename);
tbuff = gs_get_att_typbuff(gs, att, 1);
/* TODO: Provide mechanism for loading certain attributes at
specified sizes, allow scaling or capping, or scale non-zero */
if (ATT_MASK == att) {
atty = ATTY_MASK;
}
else {
atty = Gs_numtype(filename, &neg);
}
#ifdef MAYBE_LATER
if (att == ATT_COLOR && atty == ATTY_SHORT) {
atty = (neg ? ATTY_INT : ATTY_SHORT);
}
#endif
if (att == ATT_COLOR && atty == ATTY_SHORT) {
atty = ATTY_INT;
}
if (0 == gs_malloc_att_buff(gs, att, ATTY_NULL)) {
G_fatal_error(
_("GS_load_att_map(): Out of memory. Unable to load map"));
}
switch (atty) {
case ATTY_MASK:
if (0 == gs_malloc_att_buff(gs, att, ATTY_MASK)) {
G_fatal_error(
_("GS_load_att_map(): Out of memory. Unable to load map"));
}
ret = Gs_loadmap_as_bitmap(&wind, filename, tbuff->bm);
break;
case ATTY_CHAR:
if (0 == gs_malloc_att_buff(gs, att, ATTY_CHAR)) {
G_fatal_error(
_("GS_load_att_map(): Out of memory. Unable to load map"));
}
ret = Gs_loadmap_as_char(&wind, filename, tbuff->cb, tbuff->nm,
&has_null);
break;
case ATTY_SHORT:
if (0 == gs_malloc_att_buff(gs, att, ATTY_SHORT)) {
G_fatal_error(
_("GS_load_att_map(): Out of memory. Unable to load map"));
}
ret = Gs_loadmap_as_short(&wind, filename, tbuff->sb, tbuff->nm,
&has_null);
break;
case ATTY_FLOAT:
if (0 == gs_malloc_att_buff(gs, att, ATTY_FLOAT)) {
G_fatal_error(
_("GS_load_att_map(): Out of memory. Unable to load map"));
}
ret = Gs_loadmap_as_float(&wind, filename, tbuff->fb, tbuff->nm,
&has_null);
break;
case ATTY_INT:
default:
if (0 == gs_malloc_att_buff(gs, att, ATTY_INT)) {
G_fatal_error(
_("GS_load_att_map(): Out of memory. Unable to load map"));
}
ret = Gs_loadmap_as_int(&wind, filename, tbuff->ib, tbuff->nm,
&has_null);
break;
} /* Done with switch */
if (ret == -1) {
gsds_free_data_buff(gs->att[att].hdata, ATTY_NULL);
return -1;
}
G_debug(4, " has_null=%d", has_null);
if (!has_null) {
gsds_free_data_buff(gs->att[att].hdata, ATTY_NULL);
}
else {
gs_update_curmask(gs);
}
} /* end if not reuse */
if (ATT_COLOR == att) {
#ifdef MAYBE_LATER
if (ATTY_INT == atty) {
Gs_pack_colors(filename, tbuff->ib, gs->rows, gs->cols);
gsds_set_changed(gs->att[att].hdata, CF_COLOR_PACKED);
gs->att[att].lookup = NULL;
}
else {
gs_malloc_lookup(gs, att);
Gs_build_lookup(filename, gs->att[att].lookup);
}
#else
if (ATTY_CHAR == atty) {
if (!gs->att[att].lookup) {
/* might already exist if reusing */
gs_malloc_lookup(gs, att);
Gs_build_256lookup(filename, gs->att[att].lookup);
}
}
else if (ATTY_FLOAT == atty) {
if (!reuse) {
if (0 == gs_malloc_att_buff(gs, att, ATTY_INT)) {
G_fatal_error(_("GS_load_att_map(): Out of memory. Unable "
"to load map"));
}
Gs_pack_colors_float(filename, tbuff->fb, tbuff->ib, gs->rows,
gs->cols);
gsds_set_changed(gs->att[att].hdata, CF_COLOR_PACKED);
gsds_free_data_buff(gs->att[att].hdata, ATTY_FLOAT);
gs->att[att].lookup = NULL;
}
}
else {
if (!reuse) {
Gs_pack_colors(filename, tbuff->ib, gs->rows, gs->cols);
gsds_set_changed(gs->att[att].hdata, CF_COLOR_PACKED);
gs->att[att].lookup = NULL;
}
}
#endif
}
if (ATT_TOPO == att) {
gs_init_normbuff(gs);
/* S_DIFF: should also check here to see if this surface is a
reference surface for scaled differences, if so update references
to it */
}
if (ret < 0) {
G_warning(_("Loading failed"));
}
if (-1 == Gs_update_attrange(gs, att)) {
G_warning(_("Error finding range"));
}
return ret;
}
/*!
\brief Draw surface
\param id surface id
*/
void GS_draw_surf(int id)
{
geosurf *gs;
G_debug(3, "GS_draw_surf(): id=%d", id);
gs = gs_get_surf(id);
if (gs) {
gsd_shademodel(gs->draw_mode & DM_GOURAUD);
if (gs->draw_mode & DM_POLY) {
gsd_surf(gs);
}
if (gs->draw_mode & DM_WIRE) {
gsd_wire_surf(gs);
}
/* TODO: write wire/poly draw routines */
if (gs->draw_mode & DM_WIRE_POLY) {
gsd_surf(gs);
gsd_wire_surf(gs);
}
}
return;
}
/*!
\brief Draw surface wire
Overrides draw_mode for fast display
\param id surface id
*/
void GS_draw_wire(int id)
{
geosurf *gs;
G_debug(3, "GS_draw_wire(): id=%d", id);
gs = gs_get_surf(id);
if (gs) {
gsd_wire_surf(gs);
}
return;
}
/*!
\brief Draw all wires
Overrides draw_mode for fast display
*/
void GS_alldraw_wire(void)
{
geosurf *gs;
int i;
for (i = 0; i < Next_surf; i++) {
if ((gs = gs_get_surf(Surf_ID[i]))) {
gsd_wire_surf(gs);
}
}
return;
}
/*!
\brief Draw all surfaces
*/
void GS_alldraw_surf(void)
{
int i;
for (i = 0; i < Next_surf; i++) {
GS_draw_surf(Surf_ID[i]);
}
return;
}
/*!
\brief Set Z exag for surface
\param id surface id
\param exag z-exag value
*/
void GS_set_exag(int id, float exag)
{
geosurf *gs;
G_debug(3, "GS_set_exag");
gs = gs_get_surf(id);
if (gs) {
if (gs->z_exag != exag) {
gs->norm_needupdate = 1;
}
gs->z_exag = exag;
}
return;
}
/*!
\brief Set global z-exag value
\param exag exag value to be set up
*/
void GS_set_global_exag(float exag)
{
G_debug(3, "GS_set_global_exag");
Gv.vert_exag = exag;
/* GL_NORMALIZE */
/* Only need to update norms gs_norms.c
* if exag is used in norm equation which
* it is not! If GL_NORMALIZE is disabled
* will need to include.
gs_setall_norm_needupdate();
*/
return;
}
/*!
\brief Get global z-exag value
\return value
*/
float GS_global_exag(void)
{
G_debug(3, "GS_global_exag(): %g", Gv.vert_exag);
return (Gv.vert_exag);
}
/*!
\brief Set wire color
\todo error-handling
\param id surface id
\param colr color value
*/
void GS_set_wire_color(int id, int colr)
{
geosurf *gs;
G_debug(3, "GS_set_wire_color");
gs = gs_get_surf(id);
if (gs) {
gs->wire_color = colr;
}
return;
}
/*!
\brief Get wire color
\param id surface id
\param[out] colr color value
\return 1 on success
\return -1 on error
*/
int GS_get_wire_color(int id, int *colr)
{
geosurf *gs;
gs = gs_get_surf(id);
if (gs) {
*colr = gs->wire_color;
return (1);
}
return (-1);
}
/*!
\brief Set all draw-modes
\param mode mode id
\return 0 on success
\return -1 on error
*/
int GS_setall_drawmode(int mode)
{
int i;
for (i = 0; i < Next_surf; i++) {
if (0 != GS_set_drawmode(Surf_ID[i], mode)) {
return (-1);
}
}
return (0);
}
/*!
\brief Set draw mode
\param id surface id
\param mode mode type(s)
\return 0 on success
\return -1 on error (invalid surface id)
*/
int GS_set_drawmode(int id, int mode)
{
geosurf *gs;
G_debug(3, "GS_set_drawmode(): id=%d mode=%d", id, mode);
gs = gs_get_surf(id);
if (gs) {
gs->draw_mode = mode;
return (0);
}
return (-1);
}
/*!
\brief Get draw mode
\param id surface id
\param[out] mode mode id
\return 1 on success
\return -1 on error (invalid surface id)
*/
int GS_get_drawmode(int id, int *mode)
{
geosurf *gs;
gs = gs_get_surf(id);
if (gs) {
*mode = gs->draw_mode;
return (1);
}
return (-1);
}
/*!
\brief Set no-zero ?
\param id surface id
\param att attribute id
\param mode mode id
*/
void GS_set_nozero(int id, int att, int mode)
{
geosurf *gs;
G_debug(3, "GS_set_nozero");
gs = gs_get_surf(id);
if (gs) {
if (att == ATT_TOPO) {
gs->nz_topo = mode;
gs->mask_needupdate = 1;
}
if (att == ATT_COLOR) {
gs->nz_color = mode;
gs->mask_needupdate = 1;
}
}
return;
}
/*!
\brief Get no-zero ?
\param id surface id
\param att attribute id
\param[out] mode mode id
\return -1 on error (invalid surface id)
\return 1 on success
*/
int GS_get_nozero(int id, int att, int *mode)
{
geosurf *gs;
G_debug(3, "GS_set_nozero");
gs = gs_get_surf(id);
if (gs) {
if (att == ATT_TOPO) {
*mode = gs->nz_topo;
}
else if (att == ATT_COLOR) {
*mode = gs->nz_color;
}
else {
return (-1);
}
return (1);
}
return (-1);
}
/*!
\brief Set all draw resolutions
\param xres,yres x/y resolution value
\param xwire,ywire x/y wire value
\return 0 on success
\return -1 on error
*/
int GS_setall_drawres(int xres, int yres, int xwire, int ywire)
{
int i;
for (i = 0; i < Next_surf; i++) {
if (0 != GS_set_drawres(Surf_ID[i], xres, yres, xwire, ywire)) {
return (-1);
}
}
return (0);
}
/*!
\brief Set draw resolution for surface
\param id surface id
\param xres,yres x/y resolution value
\param xwire,ywire x/y wire value
\return -1 on error
\return 0 on success
*/
int GS_set_drawres(int id, int xres, int yres, int xwire, int ywire)
{
geosurf *gs;
G_debug(3, "GS_set_drawres() id=%d xyres=%d/%d xywire=%d/%d", id, xres,
yres, xwire, ywire);
if (xres < 1 || yres < 1 || xwire < 1 || ywire < 1) {
return (-1);
}
gs = gs_get_surf(id);
if (gs) {
if (gs->x_mod != xres || gs->y_mod != yres) {
gs->norm_needupdate = 1;
}
gs->x_mod = xres;
gs->y_mod = yres;
gs->x_modw = xwire;
gs->y_modw = ywire;
}
return (0);
}
/*!
\brief Get draw resolution of surface
\param id surface id
\param[out] xres,yres x/y resolution value
\param[out] xwire,ywire x/y wire value
*/
void GS_get_drawres(int id, int *xres, int *yres, int *xwire, int *ywire)
{
geosurf *gs;
G_debug(3, "GS_get_drawres");
gs = gs_get_surf(id);
if (gs) {
*xres = gs->x_mod;
*yres = gs->y_mod;
*xwire = gs->x_modw;
*ywire = gs->y_modw;
}
return;
}
/*!
\brief Get dimension of surface
\param id surface id
\param[out] rows,cols number of rows/cols
*/
void GS_get_dims(int id, int *rows, int *cols)
{
geosurf *gs;
gs = gs_get_surf(id);
if (gs) {
*rows = gs->rows;
*cols = gs->cols;
}
return;
}
/*!
\brief Get exag-value guess
Use no_zero range because if zero IS data, then range won't be that
much off (it's just a GUESS, after all), but if zero is NO data, could
drastically affect guess
\param id surface id
\param[out] exag exag value
\return 1 on success
\return -1 on error
*/
int GS_get_exag_guess(int id, float *exag)
{
geosurf *gs;
float guess;
gs = gs_get_surf(id);
guess = 1.0;
/* if gs is type const return guess = 1.0 */
if (CONST_ATT == gs_get_att_src(gs, ATT_TOPO)) {
*exag = guess;
return (1);
}
if (gs) {
if (gs->zrange_nz == 0.0) {
*exag = 0.0;
return (1);
}
G_debug(3, "GS_get_exag_guess(): %f %f", gs->zrange_nz, Longdim);
while (gs->zrange_nz * guess / Longdim >= .25) {
guess *= .1;
G_debug(3, "GS_get_exag_guess(): %f", guess);
}
while (gs->zrange_nz * guess / Longdim < .025) {
guess *= 10.;
G_debug(3, "GS_get_exag_guess(): %f", guess);
}
*exag = guess;
return (1);
}
return (-1);
}
/*!
\brief Get Z extents for all loaded surfaces
Treating zeros as "no data"
\param[out] min min value
\param[out] max max value
*/
void GS_get_zrange_nz(float *min, float *max)
{
int i, first = 1;
geosurf *gs;
for (i = 0; i < Next_surf; i++) {
if ((gs = gs_get_surf(Surf_ID[i]))) {
if (first) {
first = 0;
*min = gs->zmin_nz;
*max = gs->zmax_nz;
}
if (gs->zmin_nz < *min) {
*min = gs->zmin_nz;
}
if (gs->zmax_nz > *max) {
*max = gs->zmax_nz;
}
}
}
G_debug(3, "GS_get_zrange_nz(): min=%g max=%g", *min, *max);
return;
}
/*!
\brief Set translation (surface position)
\param id surface id
\param xtrans,ytrans,ztrans translation values
*/
void GS_set_trans(int id, float xtrans, float ytrans, float ztrans)
{
geosurf *gs;
gs = gs_get_surf(id);
if (gs) {
gs->x_trans = xtrans;
gs->y_trans = ytrans;
gs->z_trans = ztrans;
}
G_debug(3, "GS_set_trans(): id=%d, x=%f, y=%f, z=%f", id, xtrans, ytrans,
ztrans);
return;
}
/*!
\brief Get translation values (surface position)
\param id surface id
\param[out] xtrans,ytrans,ztrans trans values
*/
void GS_get_trans(int id, float *xtrans, float *ytrans, float *ztrans)
{
geosurf *gs;
gs = gs_get_surf(id);
if (gs) {
*xtrans = gs->x_trans;
*ytrans = gs->y_trans;
*ztrans = gs->z_trans;
}
G_debug(3, "GS_get_trans: id=%d, x=%f, y=%f, z=%f", id, *xtrans, *ytrans,
*ztrans);
return;
}
/*!
\brief Get default draw color
\return color value
*/
unsigned int GS_default_draw_color(void)
{
G_debug(3, "GS_default_draw_color");
return ((unsigned int)Gd.bgcol);
}
/*!
\brief Get background color
\return color value
*/
unsigned int GS_background_color(void)
{
return ((unsigned int)Gd.bgcol);
}
/*!
\brief Sets which buffer to draw to
\param where GSD_BOTH, GSD_FRONT, GSD_BACK
*/
void GS_set_draw(int where)
{
Buffermode = where;
switch (where) {
case GSD_BOTH:
gsd_bothbuffers();
break;
case GSD_FRONT:
gsd_frontbuffer();
break;
case GSD_BACK:
default:
gsd_backbuffer();
break;
}
return;
}
/*
\brief Ready to draw
*/
void GS_ready_draw(void)
{
G_debug(3, "GS_ready_draw");
gsd_set_view(&Gv, &Gd);
return;
}
/*!
\brief Draw done, swap buffers
*/
void GS_done_draw(void)
{
G_debug(3, "GS_done_draw");
if (GSD_BACK == Buffermode) {
gsd_swapbuffers();
}
gsd_flush();
return;
}
/*!
\brief Set focus
\param realto real coordinates to
*/
void GS_set_focus(float *realto)
{
G_debug(3, "GS_set_focus(): %f,%f,%f", realto[0], realto[1], realto[2]);
Gv.infocus = 1;
GS_v3eq(Gv.real_to, realto);
gsd_set_view(&Gv, &Gd);
return;
}
/*!
\brief Set real focus
\param realto real coordinates to
*/
void GS_set_focus_real(float *realto)
{
G_get_set_window(&wind);
realto[X] = realto[X] - wind.west - (wind.ew_res / 2.);
realto[Y] = realto[Y] - wind.south - (wind.ns_res / 2.);
Gv.infocus = 1;
GS_v3eq(Gv.real_to, realto);
gsd_set_view(&Gv, &Gd);
return;
}
/*!
\brief Get focus
OK to call with NULL argument if just want to check state
\param realto real coordinates to
\return ?
*/
int GS_get_focus(float *realto)
{
G_debug(3, "GS_get_focus");
if (Gv.infocus) {
if (realto) {
GS_v3eq(realto, Gv.real_to);
}
}
return (Gv.infocus);
}
/*!
\brief Set focus to map center
\param id surface id
*/
void GS_set_focus_center_map(int id)
{
float center[3];
geosurf *gs;
G_debug(3, "GS_set_focus_center_map");
gs = gs_get_surf(id);
if (gs) {
center[X] = (gs->xmax - gs->xmin) / 2.;
center[Y] = (gs->ymax - gs->ymin) / 2.;
center[Z] = (gs->zmax_nz + gs->zmin_nz) / 2.;
/* not yet working
buff = gs_get_att_typbuff(gs, ATT_TOPO, 0);
offset = gs->rows*gs->cols/2 + gs->cols/2;
if (buff)
{
if (GET_MAPATT(buff, offset, tmp))
{
center[Z] = tmp;
}
}
*/
GS_set_focus(center);
}
}
/*!
\brief Move viewpoint
\param pt 'from' model coordinates
*/
void GS_moveto(float *pt)
{
float ft[3];
G_debug(3, "GS_moveto(): %f,%f,%f", pt[0], pt[1], pt[2]);
if (Gv.infocus) {
GS_v3eq(Gv.from_to[FROM], pt);
/*
GS_v3eq(Gv.from_to[TO], Gv.real_to);
*/
GS_v3normalize(Gv.from_to[FROM], Gv.from_to[TO]);
/* update inclination, look_dir if we're keeping these */
}
else {
GS_v3eq(ft, Gv.from_to[TO]);
GS_v3sub(ft, Gv.from_to[FROM]);
GS_v3eq(Gv.from_to[FROM], pt);
GS_v3eq(Gv.from_to[TO], pt);
GS_v3add(Gv.from_to[TO], ft);
}
return;
}
/*!
\brief Move position to (real)
\param pt point real coordinates
*/
void GS_moveto_real(float *pt)
{
gsd_real2model(pt);
GS_moveto(pt);
return;
}
/*!
\brief Get z-extent for a single surface
\param id surface id
\param[out] min min z-value
\param[out] max max z-value
\param[out] mid middle z-value
\return -1 on error (invalid surface id)
\return ?
*/
int GS_get_zextents(int id, float *min, float *max, float *mid)
{
geosurf *gs;
if (NULL == (gs = gs_get_surf(id))) {
return (-1);
}
G_debug(3, "GS_get_zextents(): id=%d", id);
return (gs_get_zextents(gs, min, max, mid));
}
/*!
\brief Get z-extent for all loaded surfaces
\param[out] min min z-value
\param[out] max max z-value
\param doexag use z-exaggeration
\return 1 on success
\return -1 on error
*/
int GS_get_zrange(float *min, float *max, int doexag)
{
int ret_surf, ret_vol;
float surf_min, surf_max;
float vol_min, vol_max;
ret_surf = gs_get_zrange(&surf_min, &surf_max);
ret_vol = gvl_get_zrange(&vol_min, &vol_max);
if (ret_surf > 0 && ret_vol > 0) {
*min = (surf_min < vol_min) ? surf_min : vol_min;
*max = (surf_max < vol_max) ? surf_max : vol_max;
}
else if (ret_surf > 0) {
*min = surf_min;
*max = surf_max;
}
else if (ret_vol > 0) {
*min = vol_min;
*max = vol_max;
}
if (doexag) {
*min *= Gv.vert_exag;
*max *= Gv.vert_exag;
}
G_debug(3, "GS_get_zrange(): min=%g max=%g", *min, *max);
return ((ret_surf > 0 || ret_vol > 0) ? (1) : (-1));
}
/*!
\brief Get viewpoint 'from' position
\param[out] fr from model coordinates
*/
void GS_get_from(float *fr)
{
GS_v3eq(fr, Gv.from_to[FROM]);
G_debug(3, "GS_get_from(): %f,%f,%f", fr[0], fr[1], fr[2]);
return;
}
/*!
\brief Get viewpoint 'from' real coordinates
\param[out] fr 'from' real coordinates
*/
void GS_get_from_real(float *fr)
{
GS_v3eq(fr, Gv.from_to[FROM]);
gsd_model2real(fr);
return;
}
/*!
\brief Get 'to' real coordinates
\param[out] to 'to' real coordinates
*/
void GS_get_to_real(float *to)
{
float realto[3];
G_get_set_window(&wind);
GS_get_focus(realto);
to[X] = realto[X] + wind.west + (wind.ew_res / 2.);
to[Y] = realto[Y] + wind.south + (wind.ns_res / 2.);
to[Z] = realto[Z];
return;
}
/*!
\brief Get zoom setup
\param[out] a,b,c,d current viewport settings
\param[out] maxx,maxy max viewport size
*/
void GS_zoom_setup(int *a, int *b, int *c, int *d, int *maxx, int *maxy)
{
GLint tmp[4];
GLint num[2];
gsd_getViewport(tmp, num);
*a = tmp[0];
*b = tmp[1];
*c = tmp[2];
*d = tmp[3];
*maxx = num[0];
*maxy = num[1];
return;
}
/*!
\brief Get 'to' model coordinates
\todo need set_to? - just use viewdir?
\param[out] to 'to' model coordinates
*/
void GS_get_to(float *to)
{
G_debug(3, "GS_get_to");
GS_v3eq(to, Gv.from_to[TO]);
return;
}
/*!
\brief Get viewdir
\param[out] dir viewdir value
*/
void GS_get_viewdir(float *dir)
{
GS_v3dir(Gv.from_to[FROM], Gv.from_to[TO], dir);
return;
}
/*!
\brief Set viewdir
Automatically turns off focus
\param dir viewdir value
*/
void GS_set_viewdir(float *dir)
{
float tmp[3];
GS_v3eq(tmp, dir);
GS_v3norm(tmp);
GS_v3eq(Gv.from_to[TO], Gv.from_to[FROM]);
GS_v3add(Gv.from_to[TO], tmp);
GS_set_nofocus();
gsd_set_view(&Gv, &Gd);
return;
}
/*!
\brief Set field of view
\param fov fov value
*/
void GS_set_fov(int fov)
{
Gv.fov = fov;
return;
}
/*!
\brief Get field of view
\return field of view, in 10ths of degrees
*/
int GS_get_fov(void)
{
return (Gv.fov);
}
/*!
\brief Get twist value
10ths of degrees off twelve o'clock
*/
int GS_get_twist(void)
{
return (Gv.twist);
}
/*!
\brief Set viewpoint twist value
10ths of degrees off twelve o'clock
\param t tenths of degrees clockwise from 12:00.
*/
void GS_set_twist(int t)
{
Gv.twist = t;
return;
}
/*!
\brief Set rotation params
*/
void GS_set_rotation(double angle, double x, double y, double z)
{
Gv.rotate.rot_angle = angle;
Gv.rotate.rot_axes[0] = x;
Gv.rotate.rot_axes[1] = y;
Gv.rotate.rot_axes[2] = z;
Gv.rotate.do_rot = 1;
return;
}
/*!
\brief Stop scene rotation
*/
void GS_unset_rotation(void)
{
Gv.rotate.do_rot = 0;
}
/*!
\brief Reset scene rotation
*/
void GS_init_rotation(void)
{
int i;
for (i = 0; i < 16; i++) {
if (i == 0 || i == 5 || i == 10 || i == 15)
Gv.rotate.rotMatrix[i] = 1.0;
else
Gv.rotate.rotMatrix[i] = 0.0;
}
Gv.rotate.rot_angle = 0.0;
Gv.rotate.rot_axes[0] = 0.0;
Gv.rotate.rot_axes[1] = 0.0;
Gv.rotate.rot_axes[2] = 0.0;
Gv.rotate.do_rot = 0;
}
/*!
* \brief Get rotation matrix
*/
void GS_get_rotation_matrix(double *matrix)
{
int i;
for (i = 0; i < 16; i++) {
matrix[i] = Gv.rotate.rotMatrix[i];
}
}
/*!
* \brief Set rotation matrix
*/
void GS_set_rotation_matrix(double *matrix)
{
int i;
for (i = 0; i < 16; i++) {
Gv.rotate.rotMatrix[i] = matrix[i];
}
}
/*!
\brief Unset focus
*/
void GS_set_nofocus(void)
{
G_debug(3, "GS_set_nofocus");
Gv.infocus = 0;
return;
}
/*!
\brief Set focus
Make sure that the center of view is set
*/
void GS_set_infocus(void)
{
G_debug(3, "GS_set_infocus");
Gv.infocus = 1;
return;
}
/*!
\brief Set viewport
\param left,right,bottom,top viewport extent values
*/
void GS_set_viewport(int left, int right, int bottom, int top)
{
G_debug(3,
"GS_set_viewport(): left=%d, right=%d, "
"bottom=%d, top=%d",
left, right, bottom, top);
gsd_viewport(left, right, bottom, top);
return;
}
/*!
\brief Send screen coords sx and sy, lib traces through surfaces; sets
new center to point of nearest intersection.
If no intersection, uses line of sight with length of current view
ray (eye to center) to set new center.
Reset center of view to screen coordinates sx, sy.
\param sx,sy screen coordinates
\return 1 on success
\return 0 on error (invalid surface id)
*/
int GS_look_here(int sx, int sy)
{
float x, y, z, len, los[2][3];
Point3 realto, dir;
int id;
geosurf *gs;
if (GS_get_selected_point_on_surface(sx, sy, &id, &x, &y, &z)) {
gs = gs_get_surf(id);
if (gs) {
realto[X] = x - gs->ox + gs->x_trans;
realto[Y] = y - gs->oy + gs->y_trans;
realto[Z] = z + gs->z_trans;
GS_set_focus(realto);
return (1);
}
}
else {
if (gsd_get_los(los, (short)sx, (short)sy)) {
len = GS_distance(Gv.from_to[FROM], Gv.real_to);
GS_v3dir(los[FROM], los[TO], dir);
GS_v3mult(dir, len);
realto[X] = Gv.from_to[FROM][X] + dir[X];
realto[Y] = Gv.from_to[FROM][Y] + dir[Y];
realto[Z] = Gv.from_to[FROM][Z] + dir[Z];
GS_set_focus(realto);
return (1);
}
}
return (0);
}
/*!
\brief Get selected point of surface
Given screen coordinates sx and sy, find closest intersection of
view ray with surfaces and return coordinates of intersection in x, y,
z, and identifier of surface in id.
\param sx,sy screen coordinates
\param[out] id surface id
\param[out] x,y,z point on surface (model coordinates?)
\returns 0 if no intersections found
\return number of intersections
*/
int GS_get_selected_point_on_surface(int sx, int sy, int *id, float *x,
float *y, float *z)
{
float los[2][3], find_dist[MAX_SURFS], closest;
Point3 point, tmp, finds[MAX_SURFS];
int surfs[MAX_SURFS], i, iclose, numhits = 0;
geosurf *gs;
/* returns surface-world coords */
gsd_get_los(los, (short)sx, (short)sy);
if (!gs_setlos_enterdata(los)) {
G_debug(3, "gs_setlos_enterdata(los): returns false");
return (0);
}
for (i = 0; i < Next_surf; i++) {
G_debug(3, "id=%d", i);
gs = gs_get_surf(Surf_ID[i]);
/* los_intersect expects surf-world coords (xy transl, no scaling) */
#if NVIZ_HACK
if (gs_los_intersect1(Surf_ID[i], los, point)) {
#else
if (gs_los_intersect(Surf_ID[i], los, point)) {
#endif
if (!gs_point_is_masked(gs, point)) {
GS_v3eq(tmp, point);
tmp[X] += gs->x_trans;
tmp[Y] += gs->y_trans;
tmp[Z] += gs->z_trans;
find_dist[numhits] = GS_distance(los[FROM], tmp);
gsd_surf2real(gs, point);
GS_v3eq(finds[numhits], point);
surfs[numhits] = Surf_ID[i];
numhits++;
}
}
}
for (i = iclose = 0; i < numhits; i++) {
closest = find_dist[iclose];
if (find_dist[i] < closest) {
iclose = i;
}
}
if (numhits) {
*x = finds[iclose][X];
*y = finds[iclose][Y];
*z = finds[iclose][Z];
*id = surfs[iclose];
}
G_debug(3, "NumHits %d, next %d", numhits, Next_surf);
return (numhits);
}
/*!
\brief Set cplace rotation
\param num cplace id
\param dx,dy,dz rotation values
*/
void GS_set_cplane_rot(int num, float dx, float dy, float dz)
{
gsd_cplane_setrot(num, dx, dy, dz);
return;
}
/*!
\brief Set cplace trans
\param num cplace id
\param dx,dy,dz rotation values
*/
void GS_set_cplane_trans(int num, float dx, float dy, float dz)
{
gsd_cplane_settrans(num, dx, dy, dz);
return;
}
/*!
\brief Draw cplace
\param num cplace id
*/
void GS_draw_cplane(int num)
{
geosurf *gsurfs[MAX_SURFS];
int nsurfs;
nsurfs = gs_num_surfaces();
if (2 == nsurfs) {
/* testing */
gs_getall_surfaces(gsurfs);
gsd_draw_cplane_fence(gsurfs[0], gsurfs[1], num);
}
else {
gsd_draw_cplane(num);
}
return;
}
/*!
\brief Draw cplace fence ?
\param hs1,hs2
\param num cplane id
\return 0 on error
\return 1 on success
*/
int GS_draw_cplane_fence(int hs1, int hs2, int num)
{
geosurf *gs1, *gs2;
if (NULL == (gs1 = gs_get_surf(hs1))) {
return (0);
}
if (NULL == (gs2 = gs_get_surf(hs2))) {
return (0);
}
gsd_draw_cplane_fence(gs1, gs2, num);
return (1);
}
/*!
\brief Draw all cplace fences ?
*/
void GS_alldraw_cplane_fences(void)
{
int onstate[MAX_CPLANES], i;
gsd_get_cplanes_state(onstate);
for (i = 0; i < MAX_CPLANES; i++) {
if (onstate[i]) {
GS_draw_cplane_fence(Surf_ID[0], Surf_ID[1], i);
}
}
return;
}
/*!
\brief Set cplace
\param num cplane id
*/
void GS_set_cplane(int num)
{
gsd_cplane_on(num);
return;
}
/*!
\brief Unset clip place (turn off)
\param num cplane id
*/
void GS_unset_cplane(int num)
{
gsd_cplane_off(num);
return;
}
/*!
\brief Get axis scale
\param sx,sy,sz x/y/z scale values
\param doexag use vertical exaggeration
*/
void GS_get_scale(float *sx, float *sy, float *sz, int doexag)
{
float zexag;
zexag = doexag ? Gv.vert_exag : 1.;
*sx = *sy = Gv.scale;
*sz = Gv.scale * zexag;
return;
}
/*!
\brief Set fence color
\param mode mode id
*/
void GS_set_fencecolor(int mode)
{
gsd_setfc(mode);
return;
}
/*!
\brief Get fence color
\return color value
*/
int GS_get_fencecolor(void)
{
return gsd_getfc();
}
/*!
\brief Measure distance "as the ball rolls" between two points on
surface
\param hs surface id
\param x1,y1,x2,y2 two points on surface
\param[out] dist measured distance
\param use_exag use exag. surface
\return 0 on error or if one or more points is not in region
\return distance following terrain
*/
int GS_get_distance_alongsurf(int hs, float x1, float y1, float x2, float y2,
float *dist, int use_exag)
{
geosurf *gs;
Point3 p1, p2;
gs = gs_get_surf(hs);
if (gs == NULL) {
return 0;
}
p1[X] = x1;
p1[Y] = y1;
p2[X] = x2;
p2[Y] = y2;
gsd_real2surf(gs, p1);
gsd_real2surf(gs, p2);
G_debug(3, "GS_get_distance_alongsurf(): hs=%d p1=%f,%f p2=%f,%f", hs, x1,
y1, x2, y2);
return gs_distance_onsurf(gs, p1, p2, dist, use_exag);
}
/*!
\brief Save 3d view
\param vname view file name
\param surfid surface id
\return ?
*/
int GS_save_3dview(const char *vname, int surfid)
{
return (Gs_save_3dview(vname, &Gv, &Gd, &wind, gs_get_surf(surfid)));
}
/*!
\brief Load 3d view
\param vname view file name
\param surfid surface id
\return ?
*/
int GS_load_3dview(const char *vname, int surfid)
{
return (Gs_load_3dview(vname, &Gv, &Gd, &wind, gs_get_surf(surfid)));
/* what to do about lights - I guess, delete all &
create any that exist in 3dview file */
}
/************************************************************************
* Following routines use Graphics Library
************************************************************************/
/*!
\brief Init viewpoint
\todo allow setting center?
*/
void GS_init_view(void)
{
static int first = 1;
G_debug(3, "GS_init_view");
if (first) {
first = 0;
glMatrixMode(GL_MODELVIEW);
/* OGLXXX doublebuffer: use GLX_DOUBLEBUFFER in attriblist */
/* glxChooseVisual(*dpy, screen, *attriblist); */
/* OGLXXX
* ZMIN not needed -- always 0.
* ZMAX not needed -- always 1.
* getgdesc other posiblilties:
* glxGetConfig();
* glxGetCurrentContext();
* glxGetCurrentDrawable();
* GLint gdtmp;
* getgdesc other posiblilties:
* glxGetConfig();
* glxGetCurrentContext();
* glxGetCurrentDrawable();
* GLint gdtmp;
* glDepthRange params must be scaled to [0, 1]
*/
glDepthRange(0.0, 1.0);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
/* } */
/* replace these with something meaningful */
Gv.fov = 450;
Gv.twist = 0;
GS_init_rotation();
Gv.from_to[FROM][X] = Gv.from_to[FROM][Y] = Gv.from_to[FROM][Z] =
GS_UNIT_SIZE / 2.;
Gv.from_to[TO][X] = GS_UNIT_SIZE / 2.;
Gv.from_to[TO][Y] = GS_UNIT_SIZE / 2.;
Gv.from_to[TO][Z] = 0.;
Gv.from_to[TO][W] = Gv.from_to[FROM][W] = 1.;
Gv.real_to[W] = 1.;
Gv.vert_exag = 1.;
GS_v3eq(Gv.real_to, Gv.from_to[TO]);
GS_v3normalize(Gv.from_to[FROM], Gv.from_to[TO]);
/*
Gd.nearclip = 50;
Gd.farclip = 10000.;
*/
Gd.nearclip = 10.;
Gd.farclip = 10000.;
Gd.aspect = (float)GS_get_aspect();
GS_set_focus(Gv.real_to);
}
return;
}
/*!
\brief Clear view
\param col color value
*/
void GS_clear(int col)
{
G_debug(3, "GS_clear");
col = col | 0xFF000000;
/* OGLXXX
* change glClearDepth parameter to be in [0, 1]
* ZMAX not needed -- always 1.
* getgdesc other posiblilties:
* glxGetConfig();
* glxGetCurrentContext();
* glxGetCurrentDrawable();
* GLint gdtmp;
*/
glClearDepth(1.0);
glClearColor(
((float)((col) & 0xff)) / 255., (float)((col) >> 8 & 0xff) / 255.,
(float)((col) >> 16 & 0xff) / 255., (float)((col) >> 24 & 0xff) / 255.);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
Gd.bgcol = col;
Modelshowing = 0;
gsd_flush();
return;
}
/*!
\brief Get aspect value
\return aspect value
*/
double GS_get_aspect(void)
{
int left, right, bottom, top;
GLint tmp[4];
/* OGLXXX
* get GL_VIEWPORT:
* You can probably do better than this.
*/
glGetIntegerv(GL_VIEWPORT, tmp);
left = tmp[0];
right = tmp[0] + tmp[2] - 1;
bottom = tmp[1];
top = tmp[1] + tmp[3] - 1;
G_debug(3, "GS_get_aspect(): left=%d, right=%d, top=%d, bottom=%d", left,
right, top, bottom);
return ((double)(right - left) / (top - bottom));
}
/*!
\brief Check for transparency
Disabled.
\return 1
*/
int GS_has_transparency(void)
{
/* OGLXXX
* getgdesc other posiblilties:
* glxGetConfig();
* glxGetCurrentContext();
* glxGetCurrentDrawable();
* GLint gdtmp;
* blending is ALWAYS supported.
* This function returns whether it is enabled.
* return((glGetIntegerv(GL_BLEND, &gdtmp), gdtmp));
*/
return (1);
}
G_free
void G_free(void *buf)
Free allocated memory.
Definition alloc.c:147
NULL
#define NULL
Definition ccmath.h:32
TRUE
#define TRUE
Definition dbfopen.c:56
FALSE
#define FALSE
Definition dbfopen.c:55
G_debug
int G_debug(int level, const char *msg,...)
Print debugging message.
Definition debug.c:66
b
double b
Definition driver/set_window.c:5
t
double t
Definition driver/set_window.c:5
r
double r
Definition driver/set_window.c:5
G_find_raster2
const char * G_find_raster2(const char *name, const char *mapset)
Find a raster map (look but don't touch).
Definition find_rast.c:76
G_fatal_error
void G_fatal_error(const char *msg,...)
Print a fatal error message to stderr.
Definition gis/error.c:159
G_warning
void G_warning(const char *msg,...)
Print a warning message to stderr.
Definition gis/error.c:203
G_get_set_window
void G_get_set_window(struct Cell_head *window)
Get the current working window (region).
Definition gis/set_window.c:35
gpd_obj
void gpd_obj(geosurf *gs, gvstyle *style, Point3 pt)
Draw point representing object.
Definition gpd.c:70
GS_unset_cplane
void GS_unset_cplane(int num)
Unset clip place (turn off).
Definition gs2.c:3226
GS_zoom_setup
void GS_zoom_setup(int *a, int *b, int *c, int *d, int *maxx, int *maxy)
Get zoom setup.
Definition gs2.c:2770
GS_get_twist
int GS_get_twist(void)
Get twist value.
Definition gs2.c:2863
GS_set_cplane_rot
void GS_set_cplane_rot(int num, float dx, float dy, float dz)
Set cplace rotation.
Definition gs2.c:3122
GS_get_zextents
int GS_get_zextents(int id, float *min, float *max, float *mid)
Get z-extent for a single surface.
Definition gs2.c:2665
GS_setall_drawres
int GS_setall_drawres(int xres, int yres, int xwire, int ywire)
Set all draw resolutions.
Definition gs2.c:2199
GS_set_SDscale
int GS_set_SDscale(float scale)
Set ?
Definition gs2.c:1064
GS_set_global_exag
void GS_set_global_exag(float exag)
Set global z-exag value.
Definition gs2.c:1978
GS_new_surface
int GS_new_surface(void)
Add new surface.
Definition gs2.c:223
GS_get_modelposition
void GS_get_modelposition(float *size, float *pos)
Retrieves coordinates for lighting model position, at center of view.
Definition gs2.c:528
GS_draw_list
void GS_draw_list(GLuint list_id)
Draw pre-defined list.
Definition gs2.c:861
GS_alldraw_cplane_fences
void GS_alldraw_cplane_fences(void)
Draw all cplace fences ?
Definition gs2.c:3194
GS_get_zrange_nz
void GS_get_zrange_nz(float *min, float *max)
Get Z extents for all loaded surfaces.
Definition gs2.c:2358
GS_draw_X
void GS_draw_X(int id, float *pt)
Draw place marker.
Definition gs2.c:634
GS_set_cplane_trans
void GS_set_cplane_trans(int num, float dx, float dy, float dz)
Set cplace trans.
Definition gs2.c:3135
GS_draw_surf
void GS_draw_surf(int id)
Draw surface.
Definition gs2.c:1865
GS_draw_all_list
void GS_draw_all_list(void)
Draw all glLists.
Definition gs2.c:874
GS_set_focus
void GS_set_focus(float *realto)
Set focus.
Definition gs2.c:2520
GS_getlight_color
void GS_getlight_color(int num, float *red, float *green, float *blue)
Get light color.
Definition gs2.c:378
GS_update_normals
int GS_update_normals(int id)
Update normals.
Definition gs2.c:1113
GS_set_infocus
void GS_set_infocus(void)
Set focus.
Definition gs2.c:2965
GS_get_light_reset
int GS_get_light_reset(void)
Definition gs2.c:257
GS_load_att_map
int GS_load_att_map(int id, const char *filename, int att)
Load raster map as attribute.
Definition gs2.c:1600
GS_default_draw_color
unsigned int GS_default_draw_color(void)
Get default draw color.
Definition gs2.c:2439
GS_set_focus_real
void GS_set_focus_real(float *realto)
Set real focus.
Definition gs2.c:2538
GS_set_rotation_matrix
void GS_set_rotation_matrix(double *matrix)
Set rotation matrix.
Definition gs2.c:2939
GS_get_from
void GS_get_from(float *fr)
Get viewpoint 'from' position.
Definition gs2.c:2724
GS_get_dims
void GS_get_dims(int id, int *rows, int *cols)
Get dimension of surface.
Definition gs2.c:2280
GS_switchlight
void GS_switchlight(int num, int on)
Switch on/off light.
Definition gs2.c:470
GS_draw_cplane
void GS_draw_cplane(int num)
Draw cplace.
Definition gs2.c:3147
GS_get_viewdir
void GS_get_viewdir(float *dir)
Get viewdir.
Definition gs2.c:2807
GS_alldraw_wire
void GS_alldraw_wire(void)
Draw all wires.
Definition gs2.c:1920
GS_clear
void GS_clear(int col)
Clear view.
Definition gs2.c:3417
GS_getlight_ambient
void GS_getlight_ambient(int num, float *red, float *green, float *blue)
Get light ambient.
Definition gs2.c:422
GS_init_rotation
void GS_init_rotation(void)
Reset scene rotation.
Definition gs2.c:2907
GS_set_focus_center_map
void GS_set_focus_center_map(int id)
Set focus to map center.
Definition gs2.c:2581
GS_set_drawres
int GS_set_drawres(int id, int xres, int yres, int xwire, int ywire)
Set draw resolution for surface.
Definition gs2.c:2222
GS_look_here
int GS_look_here(int sx, int sy)
Send screen coords sx and sy, lib traces through surfaces; sets new center to point of nearest inters...
Definition gs2.c:3005
GS_set_cplane
void GS_set_cplane(int num)
Set cplace.
Definition gs2.c:3214
GS_get_att
int GS_get_att(int id, int att, int *set, float *constant, char *mapname)
Get attributes.
Definition gs2.c:1134
GS_delete_surface
int GS_delete_surface(int id)
Delete surface.
Definition gs2.c:1559
GS_update_curmask
int GS_update_curmask(int id)
Update current mask.
Definition gs2.c:991
GS_get_surf_list
int * GS_get_surf_list(int *numsurfs)
Get surface list.
Definition gs2.c:1532
GS_get_SDscale
int GS_get_SDscale(float *scale)
Get ?
Definition gs2.c:1099
GS_get_aspect
double GS_get_aspect(void)
Get aspect value.
Definition gs2.c:3450
GS_get_selected_point_on_surface
int GS_get_selected_point_on_surface(int sx, int sy, int *id, float *x, float *y, float *z)
Get selected point of surface.
Definition gs2.c:3054
GS_get_SDsurf
int GS_get_SDsurf(int *id)
Get ?
Definition gs2.c:1079
GS_new_light
int GS_new_light(void)
Add new model light.
Definition gs2.c:268
GS_draw_nline_onsurf
int GS_draw_nline_onsurf(int id, float x1, float y1, float x2, float y2, float *lasp, int n)
Draw multiline on surface.
Definition gs2.c:715
GS_get_trans
void GS_get_trans(int id, float *xtrans, float *ytrans, float *ztrans)
Get translation values (surface position).
Definition gs2.c:2416
GS_get_distance_alongsurf
int GS_get_distance_alongsurf(int hs, float x1, float y1, float x2, float y2, float *dist, int use_exag)
Measure distance "as the ball rolls" between two points on surface.
Definition gs2.c:3284
GS_get_zrange
int GS_get_zrange(float *min, float *max, int doexag)
Get z-extent for all loaded surfaces.
Definition gs2.c:2688
GS_save_3dview
int GS_save_3dview(const char *vname, int surfid)
Save 3d view.
Definition gs2.c:3315
GS_get_val_at_xy
int GS_get_val_at_xy(int id, int att, char *valstr, float x, float y)
Get RGB color at given point.
Definition gs2.c:1303
GS_draw_line_onsurf
void GS_draw_line_onsurf(int id, float x1, float y1, float x2, float y2)
Draw line on surface.
Definition gs2.c:675
GS_set_viewdir
void GS_set_viewdir(float *dir)
Set viewdir.
Definition gs2.c:2821
GS_draw_flowline_at_xy
void GS_draw_flowline_at_xy(int id, float x, float y)
Draw flow-line on surace.
Definition gs2.c:753
GS_moveto
void GS_moveto(float *pt)
Move viewpoint.
Definition gs2.c:2616
GS_get_scale
void GS_get_scale(float *sx, float *sy, float *sz, int doexag)
Get axis scale.
Definition gs2.c:3239
GS_get_fov
int GS_get_fov(void)
Get field of view.
Definition gs2.c:2853
GS_transp_is_set
int GS_transp_is_set(void)
Check if transparency is set.
Definition gs2.c:489
GS_libinit
void GS_libinit(void)
Initialize OGSF library.
Definition gs2.c:98
GS_setlight_color
void GS_setlight_color(int num, float red, float green, float blue)
Set light color.
Definition gs2.c:356
GS_get_fencecolor
int GS_get_fencecolor(void)
Get fence color.
Definition gs2.c:3267
void_func
void void_func(void)
Definition gs2.c:86
GS_get_nozero
int GS_get_nozero(int id, int att, int *mode)
Get no-zero ?
Definition gs2.c:2165
GS_set_trans
void GS_set_trans(int id, float xtrans, float ytrans, float ztrans)
Set translation (surface position).
Definition gs2.c:2392
GS_get_region
int GS_get_region(float *n, float *s, float *w, float *e)
Get 2D region extent.
Definition gs2.c:156
GS_get_drawres
void GS_get_drawres(int id, int *xres, int *yres, int *xwire, int *ywire)
Get draw resolution of surface.
Definition gs2.c:2256
GS_delete_list
void GS_delete_list(GLuint list_id)
Delete pre-defined list.
Definition gs2.c:886
GS_get_rotation_matrix
void GS_get_rotation_matrix(double *matrix)
Get rotation matrix.
Definition gs2.c:2927
GS_unset_SDsurf
void GS_unset_SDsurf(void)
Unset Scaled Difference surface.
Definition gs2.c:1027
GS_set_nozero
void GS_set_nozero(int id, int att, int mode)
Set no-zero ?
Definition gs2.c:2132
GS_set_Narrow
void GS_set_Narrow(int *pt, int id, float *pos2)
Set decoration, north arrow ??
Definition gs2.c:564
GS_get_focus
int GS_get_focus(float *realto)
Get focus.
Definition gs2.c:2562
GS_num_surfs
int GS_num_surfs(void)
Get number of surfaces.
Definition gs2.c:1517
GS_draw_fringe
void GS_draw_fringe(int id, unsigned long clr, float elev, int *where)
Draw fringe around data (surface) at selected corners.
Definition gs2.c:820
GS_unset_rotation
void GS_unset_rotation(void)
Stop scene rotation.
Definition gs2.c:2899
GS_get_wire_color
int GS_get_wire_color(int id, int *colr)
Get wire color.
Definition gs2.c:2039
GS_is_masked
int GS_is_masked(int id, float *pt)
Check if point is masked ?
Definition gs2.c:1009
GS_draw_lighting_model
void GS_draw_lighting_model(void)
Draw lighting model.
Definition gs2.c:936
GS_set_fencecolor
void GS_set_fencecolor(int mode)
Set fence color.
Definition gs2.c:3255
GS_get_exag_guess
int GS_get_exag_guess(int id, float *exag)
Get exag-value guess.
Definition gs2.c:2307
GS_set_rotation
void GS_set_rotation(double angle, double x, double y, double z)
Set rotation params.
Definition gs2.c:2885
GS_set_light_reset
void GS_set_light_reset(int i)
Definition gs2.c:250
GS_get_maskmode
int GS_get_maskmode(int id, int *mode)
Get mask mode.
Definition gs2.c:1454
GS_get_drawmode
int GS_get_drawmode(int id, int *mode)
Get draw mode.
Definition gs2.c:2110
GS_get_to
void GS_get_to(float *to)
Get 'to' model coordinates.
Definition gs2.c:2793
GS_set_wire_color
void GS_set_wire_color(int id, int colr)
Set wire color.
Definition gs2.c:2015
GS_lights_on
void GS_lights_on(void)
Switch on all lights.
Definition gs2.c:453
GS_set_exag
void GS_set_exag(int id, float exag)
Set Z exag for surface.
Definition gs2.c:1954
GS_ready_draw
void GS_ready_draw(void)
Definition gs2.c:2488
GS_surf_exists
int GS_surf_exists(int id)
Definition gs2.c:194
gsd_getViewport
int gsd_getViewport(GLint *, GLint *)
GS_draw_cplane_fence
int GS_draw_cplane_fence(int hs1, int hs2, int num)
Draw cplace fence ?
Definition gs2.c:3174
GS_setlight_position
void GS_setlight_position(int num, float xpos, float ypos, float zpos, int local)
Set light position.
Definition gs2.c:309
GS_background_color
unsigned int GS_background_color(void)
Get background color.
Definition gs2.c:2452
GS_set_drawmode
int GS_set_drawmode(int id, int mode)
Set draw mode.
Definition gs2.c:2084
GS_alldraw_surf
void GS_alldraw_surf(void)
Draw all surfaces.
Definition gs2.c:1937
GS_setall_drawmode
int GS_setall_drawmode(int mode)
Set all draw-modes.
Definition gs2.c:2062
GS_init_view
void GS_init_view(void)
Init viewpoint.
Definition gs2.c:3346
GS_set_SDsurf
int GS_set_SDsurf(int id)
Set surface as Scaled Difference surface.
Definition gs2.c:1043
GS_setlight_ambient
void GS_setlight_ambient(int num, float red, float green, float blue)
Set light ambient.
Definition gs2.c:400
GS_set_draw
void GS_set_draw(int where)
Sets which buffer to draw to.
Definition gs2.c:2462
GS_get_cat_at_xy
int GS_get_cat_at_xy(int id, int att, char *catstr, float x, float y)
Get surface category on given position.
Definition gs2.c:1177
GS_draw_legend
int GS_draw_legend(const char *name, GLuint fontbase, int size, int *flags, float *range, int *pt)
Draw legend.
Definition gs2.c:843
GS_moveto_real
void GS_moveto_real(float *pt)
Move position to (real).
Definition gs2.c:2646
GS_get_from_real
void GS_get_from_real(float *fr)
Get viewpoint 'from' real coordinates.
Definition gs2.c:2738
GS_set_att_const
int GS_set_att_const(int id, int att, float constant)
Set attribute constant.
Definition gs2.c:1405
GS_Set_ClientData
int GS_Set_ClientData(int id, void *clientd)
Set client data.
Definition gs2.c:1478
GS_load_3dview
int GS_load_3dview(const char *vname, int surfid)
Load 3d view.
Definition gs2.c:3328
GS_set_att_defaults
void GS_set_att_defaults(float *defs, float *null_defs)
Set default attributes for map objects.
Definition gs2.c:172
GS_draw_lighting_model1
void GS_draw_lighting_model1(void)
Draw lighting model.
Definition gs2.c:896
GS_set_nofocus
void GS_set_nofocus(void)
Unset focus.
Definition gs2.c:2951
GS_get_longdim
int GS_get_longdim(float *dim)
Get largest dimension.
Definition gs2.c:140
GS_unset_att
int GS_unset_att(int id, int att)
Unset attribute.
Definition gs2.c:1386
GS_set_viewport
void GS_set_viewport(int left, int right, int bottom, int top)
Set viewport.
Definition gs2.c:2979
GS_getlight_position
void GS_getlight_position(int num, float *xpos, float *ypos, float *zpos, int *local)
Get light position.
Definition gs2.c:334
GS_done_draw
void GS_done_draw(void)
Draw done, swap buffers.
Definition gs2.c:2501
GS_set_fov
void GS_set_fov(int fov)
Set field of view.
Definition gs2.c:2841
GS_get_modelposition1
void GS_get_modelposition1(float pos[])
Retrieves coordinates for lighting model position, at center of view.
Definition gs2.c:499
GS_get_norm_at_xy
int GS_get_norm_at_xy(int id, float x, float y, float *nv)
Get surface normal at x,y (real coordinates).
Definition gs2.c:1239
GS_set_maskmode
int GS_set_maskmode(int id, int mode)
Set mask mode.
Definition gs2.c:1429
GS_Get_ClientData
void * GS_Get_ClientData(int id)
Get client data.
Definition gs2.c:1500
GS_has_transparency
int GS_has_transparency(void)
Check for transparency.
Definition gs2.c:3478
GS_draw_wire
void GS_draw_wire(int id)
Draw surface wire.
Definition gs2.c:1900
GS_lights_off
void GS_lights_off(void)
Switch off all lights.
Definition gs2.c:439
GS_get_to_real
void GS_get_to_real(float *to)
Get 'to' real coordinates.
Definition gs2.c:2751
GS_set_twist
void GS_set_twist(int t)
Set viewpoint twist value.
Definition gs2.c:2875
GS_global_exag
float GS_global_exag(void)
Get global z-exag value.
Definition gs2.c:2000
Gs_load_3dview
int Gs_load_3dview(const char *vname, geoview *gv, geodisplay *gd, struct Cell_head *w, const geosurf *defsurf)
Load 3dview.
Definition gs3.c:951
Gs_loadmap_as_short
int Gs_loadmap_as_short(struct Cell_head *wind, const char *map_name, short *buff, struct BM *nullmap, int *has_null)
Load raster map as integer map.
Definition gs3.c:309
Gs_loadmap_as_bitmap
int Gs_loadmap_as_bitmap(struct Cell_head *wind, const char *map_name, struct BM *buff)
Load raster map as integer map.
Definition gs3.c:516
Gs_numtype
int Gs_numtype(const char *filename, int *negflag)
Get map data type.
Definition gs3.c:227
Gs_pack_colors
void Gs_pack_colors(const char *filename, int *buff, int rows, int cols)
Pack color table.
Definition gs3.c:637
Gs_pack_colors_float
void Gs_pack_colors_float(const char *filename, float *fbuf, int *ibuf, int rows, int cols)
Pack color table (floating-point map).
Definition gs3.c:705
Gs_loadmap_as_char
int Gs_loadmap_as_char(struct Cell_head *wind, const char *map_name, unsigned char *buff, struct BM *nullmap, int *has_null)
Load raster map as integer map.
Definition gs3.c:415
Gs_save_3dview
int Gs_save_3dview(const char *vname, geoview *gv, geodisplay *gd, struct Cell_head *w, geosurf *defsurf)
Save 3dview.
Definition gs3.c:852
Gs_loadmap_as_float
int Gs_loadmap_as_float(struct Cell_head *wind, const char *map_name, float *buff, struct BM *nullmap, int *has_null)
Load raster map as floating point map.
Definition gs3.c:109
Gs_get_cat_label
int Gs_get_cat_label(const char *filename, int drow, int dcol, char *catstr)
Get categories/labels.
Definition gs3.c:776
Gs_build_256lookup
int Gs_build_256lookup(const char *filename, int *buff)
Build color table (256).
Definition gs3.c:576
Gs_update_attrange
int Gs_update_attrange(geosurf *gs, int desc)
Update no_zero ranges for attribute (actually no_null now).
Definition gs3.c:1084
Gs_loadmap_as_int
int Gs_loadmap_as_int(struct Cell_head *wind, const char *map_name, int *buff, struct BM *nullmap, int *has_null)
Load raster map as integer map.
Definition gs3.c:174
gs_get_datacenter
int gs_get_datacenter(float *cen)
Get data center point.
Definition gs.c:1230
gs_get_zextents
int gs_get_zextents(geosurf *gs, float *min, float *max, float *mid)
Get z-extent values.
Definition gs.c:997
gs_get_zrange
int gs_get_zrange(float *min, float *max)
Get z-range.
Definition gs.c:1086
gs_malloc_att_buff
size_t gs_malloc_att_buff(geosurf *gs, int desc, int type)
Allocate attribute buffer.
Definition gs.c:717
gs_set_att_src
int gs_set_att_src(geosurf *gs, int desc, int src)
Set attribute source.
Definition gs.c:826
gs_mapcolor
int gs_mapcolor(typbuff *cobuff, gsurf_att *coloratt, int offset)
Call this one when you already know att_src is MAP_ATT.
Definition gs.c:968
gs_get_surf
geosurf * gs_get_surf(int id)
Get geosurf struct.
Definition gs.c:63
gs_set_att_const
int gs_set_att_const(geosurf *gs, int desc, float constant)
Set attribute constant value.
Definition gs.c:871
gs_malloc_lookup
int gs_malloc_lookup(geosurf *gs, int desc)
Allocate attribute lookup.
Definition gs.c:746
gs_delete_surf
void gs_delete_surf(int id)
Remove geosurf struct from list.
Definition gs.c:463
gs_set_att_type
int gs_set_att_type(geosurf *gs, int desc, int type)
Set attribute type.
Definition gs.c:802
gs_getall_surfaces
int gs_getall_surfaces(geosurf **gsurfs)
Get array of geosurf structs.
Definition gs.c:109
gs_init_surf
int gs_init_surf(geosurf *gs, double ox, double oy, int rows, int cols, double xres, double yres)
Initialize allocated geosurf struct.
Definition gs.c:234
gs_init
void gs_init(void)
Initialize library.
Definition gs.c:48
gs_get_new_surface
geosurf * gs_get_new_surface(void)
Allocate new geosurf struct.
Definition gs.c:194
gs_distance_onsurf
int gs_distance_onsurf(geosurf *gs, float *p1, float *p2, float *dist, int use_exag)
Calculate distance on surface.
Definition gs.c:1414
gs_num_surfaces
int gs_num_surfaces(void)
Get number of surfaces.
Definition gs.c:128
gs_init_normbuff
int gs_init_normbuff(geosurf *gs)
Init geosurf normbuff.
Definition gs.c:308
gs_get_att_typbuff
typbuff * gs_get_att_typbuff(geosurf *gs, int desc, int to_write)
Get attribute data buffer.
Definition gs.c:681
gs_point_is_masked
int gs_point_is_masked(geosurf *gs, float *pt)
Check if point is masked.
Definition gs.c:1314
gs_get_data_avg_zmax
int gs_get_data_avg_zmax(float *azmax)
Get average z-max value.
Definition gs.c:1201
gs_att_is_set
int gs_att_is_set(geosurf *surf, IFLAG att)
Check if attribute is set.
Definition gs.c:150
gs_get_att_src
int gs_get_att_src(geosurf *gs, int desc)
Get attribute source.
Definition gs.c:656
gs_set_defaults
void gs_set_defaults(geosurf *gs, float *defs, float *null_defs)
Set default attribute values.
Definition gs.c:441
gs_update_curmask
int gs_update_curmask(geosurf *surf)
Update current maps.
Definition gs_bm.c:228
gs_calc_normals
int gs_calc_normals(geosurf *gs)
Calculate normals.
Definition gs_norms.c:124
gs_los_intersect1
int gs_los_intersect1(int surfid, float(*los)[3], float *point)
Crude method of intersecting line of sight with closest part of surface.
Definition gs_query.c:52
gs_setlos_enterdata
int gs_setlos_enterdata(Point3 *los)
Definition gs_query.c:529
gs_los_intersect
int gs_los_intersect(int surfid, float **los, float *point)
Crude method of intersecting line of sight with closest part of surface.
Definition gs_query.c:192
GS_v3sub
void GS_v3sub(float *v1, float *v2)
Subtract vectors.
Definition gs_util.c:212
GS_v3mult
void GS_v3mult(float *v1, float k)
Multiple vectors.
Definition gs_util.c:229
GS_coordpair_repeats
int GS_coordpair_repeats(float *p1, float *p2, int nhist)
ADD.
Definition gs_util.c:440
GS_distance
float GS_distance(float *from, float *to)
Calculate distance.
Definition gs_util.c:141
GS_v2norm
int GS_v2norm(float *v1)
Change v1 so that it is a unit vector (2D).
Definition gs_util.c:271
GS_v3add
void GS_v3add(float *v1, float *v2)
Sum vectors.
Definition gs_util.c:195
GS_v3norm
int GS_v3norm(float *v1)
Change v1 so that it is a unit vector (3D).
Definition gs_util.c:246
GS_v3eq
void GS_v3eq(float *v1, float *v2)
Copy vector values.
Definition gs_util.c:178
GS_v3dir
int GS_v3dir(float *v1, float *v2, float *v3)
Get a normalized direction from v1 to v2, store in v3.
Definition gs_util.c:351
GS_v3normalize
int GS_v3normalize(float *v1, float *v2)
Change v2 so that v1v2 is a unit vector.
Definition gs_util.c:321
gsd_cplane_off
void gsd_cplane_off(int num)
Turn off clip plane.
Definition gsd_cplane.c:126
gsd_get_cplanes_state
void gsd_get_cplanes_state(int *onstate)
Get cplane state.
Definition gsd_cplane.c:142
gsd_cplane_settrans
void gsd_cplane_settrans(int num, float tx, float ty, float tz)
ADD.
Definition gsd_cplane.c:229
gsd_draw_cplane_fence
void gsd_draw_cplane_fence(geosurf *surf1, geosurf *surf2, int cpnum)
ADD.
Definition gsd_cplane.c:247
gsd_draw_cplane
void gsd_draw_cplane(int num)
Draw cplane.
Definition gsd_cplane.c:296
gsd_cplane_setrot
void gsd_cplane_setrot(int num, float rx, float ry, float rz)
ADD.
Definition gsd_cplane.c:211
gsd_cplane_on
void gsd_cplane_on(int num)
ADD.
Definition gsd_cplane.c:104
gsd_display_fringe
void gsd_display_fringe(geosurf *surf, unsigned long clr, float elev, int where[4])
Display fridge.
Definition gsd_fringe.c:51
gsd_put_legend
GLuint gsd_put_legend(const char *name, GLuint fontbase, int size, int *flags, float *rangef, int *pt)
Put legend.
Definition gsd_legend.c:201
gsd_line_onsurf
void gsd_line_onsurf(geosurf *gs, float *v1, float *v2)
Line on surface, fix z-values.
Definition gsd_objs.c:171
gsd_drawsphere
void gsd_drawsphere(float *center, unsigned long colr, float siz)
Draws a sphere at the specified center location.
Definition gsd_objs.c:565
gsd_nline_onsurf
int gsd_nline_onsurf(geosurf *gs, float *v1, float *v2, float *pt, int n)
Multiline on surface, fix z-values.
Definition gsd_objs.c:216
gsd_viewport
void gsd_viewport(int l, int r, int b, int t)
Set the viewport.
Definition gsd_prim.c:1077
gsd_backface
void gsd_backface(int n)
ADD.
Definition gsd_prim.c:254
gsd_pushmatrix
void gsd_pushmatrix(void)
Push the current matrix stack.
Definition gsd_prim.c:511
gsd_calllist
void gsd_calllist(int listno)
ADD.
Definition gsd_prim.c:1173
gsd_zwritemask
void gsd_zwritemask(unsigned long n)
Write out z-mask.
Definition gsd_prim.c:241
gsd_deflight
void gsd_deflight(int num, struct lightdefs *vals)
Define light.
Definition gsd_prim.c:836
gsd_switchlight
void gsd_switchlight(int num, int on)
Switch light on/off.
Definition gsd_prim.c:877
INT_TO_GRN
#define INT_TO_GRN(i, g)
Definition gsd_prim.c:54
gsd_colormode
void gsd_colormode(int cm)
Set color mode.
Definition gsd_prim.c:98
gsd_init_lightmodel
void gsd_init_lightmodel(void)
Initialize model light.
Definition gsd_prim.c:719
gsd_swapbuffers
void gsd_swapbuffers(void)
Swap buffers.
Definition gsd_prim.c:482
INT_TO_RED
#define INT_TO_RED(i, r)
Definition gsd_prim.c:53
INT_TO_BLU
#define INT_TO_BLU(i, b)
Definition gsd_prim.c:55
gsd_backbuffer
void gsd_backbuffer(void)
Draw to the back buffer.
Definition gsd_prim.c:470
gsd_popmatrix
void gsd_popmatrix(void)
Pop the current matrix stack.
Definition gsd_prim.c:501
gsd_flush
void gsd_flush(void)
Mostly for flushing drawing commands across a network.
Definition gsd_prim.c:84
gsd_calllists
void gsd_calllists(int listno)
ADD.
Definition gsd_prim.c:1185
gsd_deletelist
void gsd_deletelist(GLuint listno, int range)
Delete list.
Definition gsd_prim.c:1153
gsd_scale
void gsd_scale(float xs, float ys, float zs)
Multiply the current matrix by a general scaling matrix.
Definition gsd_prim.c:525
gsd_translate
void gsd_translate(float dx, float dy, float dz)
Multiply the current matrix by a translation matrix.
Definition gsd_prim.c:539
gsd_color_func
void gsd_color_func(unsigned int col)
Set current color.
Definition gsd_prim.c:698
gsd_shademodel
void gsd_shademodel(int shade)
Set shaded model.
Definition gsd_prim.c:419
gsd_bothbuffers
void gsd_bothbuffers(void)
Draw to the front and back buffers.
Definition gsd_prim.c:446
gsd_frontbuffer
void gsd_frontbuffer(void)
Draw to the front buffer.
Definition gsd_prim.c:458
gsd_linewidth
void gsd_linewidth(short n)
Set width of rasterized lines.
Definition gsd_prim.c:267
gsd_getfc
int gsd_getfc(void)
ADD.
Definition gsd_surf.c:1217
gsd_setfc
void gsd_setfc(int mode)
ADD.
Definition gsd_surf.c:1205
gsd_surf
int gsd_surf(geosurf *surf)
ADD.
Definition gsd_surf.c:80
gsd_real2model
void gsd_real2model(Point3 point)
Convert real to model coordinates.
Definition gsd_views.c:373
gsd_surf2real
void gsd_surf2real(geosurf *gs, Point3 point)
Convert surface to real coordinates.
Definition gsd_views.c:465
gsd_get_los
int gsd_get_los(float(*vect)[3], short sx, short sy)
ADD.
Definition gsd_views.c:40
gsd_real2surf
void gsd_real2surf(geosurf *gs, Point3 point)
Convert real to surface coordinates.
Definition gsd_views.c:481
gsd_model2real
void gsd_model2real(Point3 point)
Convert model to real coordinates.
Definition gsd_views.c:393
gsd_do_scale
void gsd_do_scale(int doexag)
Set current scale.
Definition gsd_views.c:355
gsd_set_view
void gsd_set_view(geoview *gv, geodisplay *gd)
Set view.
Definition gsd_views.c:146
gsd_wire_surf
int gsd_wire_surf(geosurf *surf)
Draw surface wire.
Definition gsd_wire.c:46
gsdiff_set_SDscale
void gsdiff_set_SDscale(float scale)
Set scale.
Definition gsdiff.c:42
gsdiff_get_SDscale
float gsdiff_get_SDscale(void)
Get scale.
Definition gsdiff.c:54
gsdiff_set_SDref
void gsdiff_set_SDref(geosurf *gsref)
ADD.
Definition gsdiff.c:64
gsdiff_get_SDref
geosurf * gsdiff_get_SDref(void)
ADD.
Definition gsdiff.c:77
in_vregion
int in_vregion(geosurf *gs, float *pt)
ADD.
Definition gsdrape.c:698
_viewcell_tri_interp
int _viewcell_tri_interp(geosurf *gs, Point3 pt)
ADD.
Definition gsdrape.c:464
gsds_get_name
char * gsds_get_name(int id)
Get name.
Definition gsds.c:303
gsds_newh
int gsds_newh(const char *name)
Get handle to gsds.
Definition gsds.c:219
gsds_findh
int gsds_findh(const char *name, IFLAG *changes, IFLAG *types, int begin)
Get handle to gsds.
Definition gsds.c:188
gsds_set_changed
int gsds_set_changed(int id, IFLAG reason)
ADD.
Definition gsds.c:633
gsds_free_data_buff
int gsds_free_data_buff(int id, int typ)
Free allocated buffer.
Definition gsds.c:369
gsget.h
FNORM
#define FNORM(i, nv)
Definition gsget.h:51
GET_MAPATT
#define GET_MAPATT(buff, offset, att)
Definition gsget.h:29
Cxl_func
void(* Cxl_func)(void)
Definition gsx.c:21
gv_update_drapesurfs
void gv_update_drapesurfs(void)
Update drape surfaces.
Definition gv.c:157
gvl_get_zrange
int gvl_get_zrange(float *min, float *max)
Get volume z-range value.
Definition gvl.c:478
g
float g
Definition named_colr.c:7
name
const char * name
Definition named_colr.c:6
G_fully_qualified_name
char * G_fully_qualified_name(const char *name, const char *mapset)
Get fully qualified element name.
Definition nme_in_mps.c:101
strcpy
#define strcpy
Definition parson.c:66
min
#define min(a, b)
Definition pngdriver/draw_bitmap.c:19
max
#define max(a, b)
Definition pngdriver/draw_bitmap.c:22
rgbpack.h
rowcol.h
VYRES
#define VYRES(gs)
Definition rowcol.h:10
Y2VROW
#define Y2VROW(gs, py)
Definition rowcol.h:27
VXRES
#define VXRES(gs)
Definition rowcol.h:9
DRC2OFF
#define DRC2OFF(gs, drow, dcol)
Definition rowcol.h:17
VROW2DROW
#define VROW2DROW(gs, vrow)
Definition rowcol.h:31
X2VCOL
#define X2VCOL(gs, px)
Definition rowcol.h:28
VCOL2DCOL
#define VCOL2DCOL(gs, vcol)
Definition rowcol.h:32
X
#define X(j)
x
#define x
Y
#define Y(j)