← Back to branch summary

~ubuntu-branches/ubuntu/vivid/grass/vivid-proposed

« back to all changes in this revision

Viewing changes to visualization/nviz/src/lights.c

  • Committer: Package Import Robot
  • Author(s): Bas Couwenberg
  • Date: 2015-02-20 23:12:08 UTC
  • mfrom: (8.2.6 experimental)
  • Revision ID: package-import@ubuntu.com-20150220231208-1u6qvqm84v430b10
Tags: 7.0.0-1~exp1
* New upstream release.
* Update python-ctypes-ternary.patch to use if/else instead of and/or.
* Drop check4dev patch, rely on upstream check.
* Add build dependency on libpq-dev to grass-dev for libpq-fe.h.
* Drop patches applied upstream, refresh remaining patches.
* Update symlinks for images switched from jpg to png.

Show diffs side-by-side

added added

removed removed

Lines of Context:
visualization/nviz/src/lights.c
1
 
#include <stdlib.h>
2
 
#include "interface.h"
3
 
 
4
 
static int setlgt_ambient(Nv_data *, Tcl_Interp *, int, char **);
5
 
static int getlgt_bright(Nv_data *, Tcl_Interp *, int, char **);
6
 
static int getlgt_ambient(Nv_data *, Tcl_Interp *, int, char **);
7
 
static int getlgt_color(Nv_data *, Tcl_Interp *, int, char **);
8
 
static int getlgt_position(Nv_data *, Tcl_Interp *, int, char **);
9
 
static int setlgt_bright(Nv_data *, Tcl_Interp *, int, char **);
10
 
static int setlgt_color(Nv_data *, Tcl_Interp *, int, char **);
11
 
static int setlgt_position(Nv_data *, Tcl_Interp *, int, char **);
12
 
static int switchlight(int, char **);
13
 
static int get_light_num(char *);
14
 
static int init_new_light(Nv_data *, int);
15
 
 
16
 
int Nlight_obj_cmd(Nv_data * data, Tcl_Interp * interp, /* Current interpreter. */
17
 
                   int argc,    /* Number of arguments. */
18
 
                   char **argv  /* Argument strings. */
19
 
    )
20
 
{
21
 
    if (!strcmp(argv[1], "set_ambient"))
22
 
        return (setlgt_ambient(data, interp, argc, argv));
23
 
    else if (!strcmp(argv[1], "get_ambient"))
24
 
        return (getlgt_ambient(data, interp, argc, argv));
25
 
    else if (!strcmp(argv[1], "set_bright"))
26
 
        return (setlgt_bright(data, interp, argc, argv));
27
 
    else if (!strcmp(argv[1], "get_bright"))
28
 
        return (getlgt_bright(data, interp, argc, argv));
29
 
    else if (!strcmp(argv[1], "set_color"))
30
 
        return (setlgt_color(data, interp, argc, argv));
31
 
    else if (!strcmp(argv[1], "get_color"))
32
 
        return (getlgt_color(data, interp, argc, argv));
33
 
    else if (!strcmp(argv[1], "set_position"))
34
 
        return (setlgt_position(data, interp, argc, argv));
35
 
    else if (!strcmp(argv[1], "get_position"))
36
 
        return (getlgt_position(data, interp, argc, argv));
37
 
    else if (!strcmp(argv[1], "switch"))
38
 
        return (switchlight(argc, argv));
39
 
    else
40
 
        return (TCL_ERROR);
41
 
}
42
 
 
43
 
int Nnew_light_cmd(Nv_data * data, Tcl_Interp * interp  /* Current interpreter. */
44
 
    )
45
 
{
46
 
    char buf[128];
47
 
    int num;
48
 
 
49
 
    if (0 > (num = GS_new_light())) {
50
 
        Tcl_SetResult(interp, "too many lights", TCL_VOLATILE);
51
 
        return (TCL_ERROR);
52
 
    }
53
 
    sprintf(buf, "Nlight%d", num);
54
 
    init_new_light(data, num);
55
 
    Tcl_CreateCommand(interp, buf, (Tcl_CmdProc *) Nlight_obj_cmd, data,
56
 
                      NULL);
57
 
    Tcl_SetResult(interp, buf, TCL_VOLATILE);
58
 
    return (TCL_OK);
59
 
}
60
 
 
61
 
int Nlights_cmd(Nv_data * data, Tcl_Interp * interp,    /* Current interpreter. */
62
 
                int argc,       /* Number of arguments. */
63
 
                char **argv     /* Argument strings. */
64
 
    )
65
 
{
66
 
    if (argc == 2)
67
 
        if (!strcmp(argv[1], "off")) {
68
 
            GS_lights_off();
69
 
            return (TCL_OK);
70
 
        }
71
 
    GS_lights_on();
72
 
    return (TCL_OK);
73
 
}
74
 
 
75
 
static int setlgt_ambient(Nv_data * data, Tcl_Interp * interp,  /* Current interpreter. */
76
 
                          int argc,     /* Number of arguments. */
77
 
                          char **argv   /* Argument strings. */
78
 
    )
79
 
{
80
 
    int num;
81
 
    float r, g, b;
82
 
 
83
 
    if (argc != 5)
84
 
        return (TCL_ERROR);
85
 
    num = get_light_num(argv[0]);
86
 
    data->light[num].ar = r = (float)atof(argv[2]);
87
 
    data->light[num].ag = g = (float)atof(argv[3]);
88
 
    data->light[num].ab = b = (float)atof(argv[4]);
89
 
    GS_setlight_ambient(num, r, g, b);
90
 
    return (TCL_OK);
91
 
}
92
 
 
93
 
static int getlgt_bright(Nv_data * data, Tcl_Interp * interp, int argc, /* Number of arguments. */
94
 
                         char **argv    /* Argument strings. */
95
 
    )
96
 
{
97
 
    int num;
98
 
    char bright[32];
99
 
 
100
 
    num = get_light_num(argv[0]);
101
 
    sprintf(bright, "%f", data->light[num].brt);
102
 
    Tcl_SetResult(interp, bright, TCL_VOLATILE);
103
 
    return (TCL_OK);
104
 
}
105
 
 
106
 
static int getlgt_ambient(Nv_data * data, Tcl_Interp * interp, int argc,        /* Number of arguments. */
107
 
                          char **argv   /* Argument strings. */
108
 
    )
109
 
{
110
 
    int num;
111
 
    char r[32], g[32], b[32];
112
 
    char *list[4];
113
 
 
114
 
    num = get_light_num(argv[0]);
115
 
    sprintf(r, "%f", data->light[num].ar);
116
 
    sprintf(g, "%f", data->light[num].ag);
117
 
    sprintf(b, "%f", data->light[num].ab);
118
 
    list[0] = r;
119
 
    list[1] = g;
120
 
    list[2] = b;
121
 
    list[3] = NULL;
122
 
 
123
 
    Tcl_SetResult(interp, Tcl_Merge(3, list), TCL_DYNAMIC);
124
 
    return (TCL_OK);
125
 
}
126
 
 
127
 
static int getlgt_color(Nv_data * data, Tcl_Interp * interp, int argc,  /* Number of arguments. */
128
 
                        char **argv     /* Argument strings. */
129
 
    )
130
 
{
131
 
    int num;
132
 
    char r[32], g[32], b[32];
133
 
    char *list[4];
134
 
 
135
 
    num = get_light_num(argv[0]);
136
 
    sprintf(r, "%f", data->light[num].r);
137
 
    sprintf(g, "%f", data->light[num].g);
138
 
    sprintf(b, "%f", data->light[num].b);
139
 
    list[0] = r;
140
 
    list[1] = g;
141
 
    list[2] = b;
142
 
    list[3] = NULL;
143
 
 
144
 
    Tcl_SetResult(interp, Tcl_Merge(3, list), TCL_DYNAMIC);
145
 
    return (TCL_OK);
146
 
}
147
 
 
148
 
static int getlgt_position(Nv_data * data, Tcl_Interp * interp, int argc,       /* Number of arguments. */
149
 
                           char **argv  /* Argument strings. */
150
 
    )
151
 
{
152
 
    int num;
153
 
    char x[32], y[32], z[32], w[32];
154
 
    char *list[5];
155
 
 
156
 
    num = get_light_num(argv[0]);
157
 
    sprintf(x, "%f", data->light[num].x);
158
 
    sprintf(y, "%f", data->light[num].y);
159
 
    sprintf(z, "%f", data->light[num].z);
160
 
    sprintf(w, "%f", data->light[num].w);
161
 
    list[0] = x;
162
 
    list[1] = y;
163
 
    list[2] = z;
164
 
    list[3] = w;
165
 
    list[4] = NULL;
166
 
 
167
 
    Tcl_SetResult(interp, Tcl_Merge(4, list), TCL_DYNAMIC);
168
 
    return (TCL_OK);
169
 
}
170
 
 
171
 
 
172
 
static int setlgt_bright(Nv_data * data, Tcl_Interp * interp,   /* Current interpreter. */
173
 
                         int argc,      /* Number of arguments. */
174
 
                         char **argv    /* Argument strings. */
175
 
    )
176
 
{
177
 
    int num;
178
 
    float r, g, b;
179
 
    double atof();
180
 
 
181
 
    if (argc != 3)
182
 
        return (TCL_ERROR);
183
 
    num = get_light_num(argv[0]);
184
 
 
185
 
    data->light[num].brt = (float)atof(argv[2]);
186
 
 
187
 
    r = data->light[num].r * data->light[num].brt;
188
 
    g = data->light[num].g * data->light[num].brt;
189
 
    b = data->light[num].b * data->light[num].brt;
190
 
 
191
 
    GS_setlight_color(num, r, g, b);
192
 
    return (TCL_OK);
193
 
}
194
 
 
195
 
static int setlgt_color(Nv_data * data, Tcl_Interp * interp,    /* Current interpreter. */
196
 
                        int argc,       /* Number of arguments. */
197
 
                        char **argv     /* Argument strings. */
198
 
    )
199
 
{
200
 
    int num;
201
 
    float r, g, b;
202
 
    double atof();
203
 
 
204
 
    if (argc != 5)
205
 
        return (TCL_ERROR);
206
 
    num = get_light_num(argv[0]);
207
 
 
208
 
    data->light[num].r = (float)atof(argv[2]);
209
 
    data->light[num].g = (float)atof(argv[3]);
210
 
    data->light[num].b = (float)atof(argv[4]);
211
 
 
212
 
    r = data->light[num].r * data->light[num].brt;
213
 
    g = data->light[num].g * data->light[num].brt;
214
 
    b = data->light[num].b * data->light[num].brt;
215
 
 
216
 
    GS_setlight_color(num, r, g, b);
217
 
    return (TCL_OK);
218
 
}
219
 
 
220
 
static int setlgt_position(Nv_data * data, Tcl_Interp * interp, /* Current interpreter. */
221
 
                           int argc,    /* Number of arguments. */
222
 
                           char **argv  /* Argument strings. */
223
 
    )
224
 
{
225
 
    int num, w;
226
 
    float x, y, z;
227
 
    double atof();
228
 
 
229
 
    if (argc != 6)
230
 
        return (TCL_ERROR);
231
 
 
232
 
    num = get_light_num(argv[0]);
233
 
 
234
 
    data->light[num].x = x = (float)atof(argv[2]);
235
 
    data->light[num].y = y = (float)atof(argv[3]);
236
 
    data->light[num].z = z = (float)atof(argv[4]);
237
 
    data->light[num].w = w = (float)atoi(argv[5]);
238
 
    GS_setlight_position(num, x, y, z, w);
239
 
    return (TCL_OK);
240
 
}
241
 
 
242
 
static int switchlight(int argc,        /* Number of arguments. */
243
 
                       char **argv      /* Argument strings. */
244
 
    )
245
 
{
246
 
    int on, num;
247
 
 
248
 
    if (argc != 3)
249
 
        return (TCL_ERROR);
250
 
    on = (strcmp(argv[0], "off"));
251
 
    num = get_light_num(argv[3]);
252
 
    GS_switchlight(num, on);
253
 
    return (TCL_OK);
254
 
}
255
 
 
256
 
static int get_light_num(char *lgt)
257
 
{
258
 
    int num;
259
 
 
260
 
    sscanf(lgt, "Nlight%d", &num);
261
 
 
262
 
    return num;
263
 
}
264
 
 
265
 
static int init_new_light(Nv_data * data, int n)
266
 
{
267
 
    data->light[n].brt = 0.8;
268
 
    data->light[n].ar = 0.3;
269
 
    data->light[n].ag = 0.3;
270
 
    data->light[n].ab = 0.3;
271
 
    data->light[n].r = 1.0;
272
 
    data->light[n].b = 1.0;
273
 
    data->light[n].g = 1.0;
274
 
    data->light[n].x = 1.0;
275
 
    data->light[n].y = 1.0;
276
 
    data->light[n].z = 1.0;
277
 
    data->light[n].w = 1.0;
278
 
 
279
 
    return 0;
280
 
}