]> git.jsancho.org Git - guile-irrlicht.git/blob - src/material.cpp
begin-scene
[guile-irrlicht.git] / src / material.cpp
1 /* guile-irrlicht --- GNU Guile bindings for Irrlicht Engine
2
3    Copyright (C) 2020 Javier Sancho <jsf@jsancho.org>
4
5    This file is part of guile-irrlicht.
6
7    guile-irrlicht is free software; you can redistribute it and/or modify
8    it under the terms of the GNU Lesser General Public License as
9    published by the Free Software Foundation; either version 3 of the
10    License, or (at your option) any later version.
11
12    guile-irrlicht is distributed in the hope that it will be useful, but
13    WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15    General Public License for more details.
16
17    You should have received a copy of the GNU Lesser General Public
18    License along with guile-irrlicht. If not, see
19    <http://www.gnu.org/licenses/>.
20 */
21
22 #include <irrlicht/irrlicht.h>
23 #include <libguile.h>
24
25 #include "color.h"
26 #include "gsubr.h"
27 #include "material.h"
28 #include "material-types.h"
29
30
31 using namespace irr;
32
33
34 SCM
35 video_SMaterial_make (SCM rest)
36 {
37   SCM material_type;
38   SCM ambient_color;
39   SCM diffuse_color;
40   SCM emissive_color;
41   SCM specular_color;
42   SCM shininess;
43   SCM material_type_param;
44   SCM material_type_param_2;
45   SCM thickness;
46   SCM z_buffer;
47   SCM anti_aliasing;
48   SCM color_mask;
49   SCM color_material;
50   SCM blend_operation;
51   SCM polygon_offset_factor;
52   SCM polygon_offset_direction;
53   SCM wireframe;
54   SCM point_cloud;
55   SCM gouraud_shading;
56   SCM lighting;
57   SCM z_write_enable;
58   SCM backface_culling;
59   SCM frontface_culling;
60   SCM fog_enable;
61   SCM normalize_normals;
62   SCM use_mip_maps;
63
64   scm_c_bind_keyword_arguments
65     ("video_SMaterial_make", rest, (scm_t_keyword_arguments_flags)0,
66      scm_from_utf8_keyword ("material-type"), &material_type,
67      scm_from_utf8_keyword ("ambient-color"), &ambient_color,
68      scm_from_utf8_keyword ("diffuse-color"), &diffuse_color,
69      scm_from_utf8_keyword ("emissive-color"), &emissive_color,
70      scm_from_utf8_keyword ("specular-color"), &specular_color,
71      scm_from_utf8_keyword ("shininess"), &shininess,
72      scm_from_utf8_keyword ("material-type-param"), &material_type_param,
73      scm_from_utf8_keyword ("material-type-param-2"), &material_type_param_2,
74      scm_from_utf8_keyword ("thickness"), &thickness,
75      scm_from_utf8_keyword ("z-buffer"), &z_buffer,
76      scm_from_utf8_keyword ("anti-aliasing"), &anti_aliasing,
77      scm_from_utf8_keyword ("color-mask"), &color_mask,
78      scm_from_utf8_keyword ("color-material"), &color_material,
79      scm_from_utf8_keyword ("blend-operation"), &blend_operation,
80      scm_from_utf8_keyword ("polygon-offset-factor"), &polygon_offset_factor,
81      scm_from_utf8_keyword ("polygon-offset-direction"), &polygon_offset_direction,
82      scm_from_utf8_keyword ("wireframe"), &wireframe,
83      scm_from_utf8_keyword ("point-cloud"), &point_cloud,
84      scm_from_utf8_keyword ("gouraud-shading"), &gouraud_shading,
85      scm_from_utf8_keyword ("lighting"), &lighting,
86      scm_from_utf8_keyword ("z-write-enable"), &z_write_enable,
87      scm_from_utf8_keyword ("backface-culling"), &backface_culling,
88      scm_from_utf8_keyword ("frontface-culling"), &frontface_culling,
89      scm_from_utf8_keyword ("fog-enable"), &fog_enable,
90      scm_from_utf8_keyword ("normalize-normals"), &normalize_normals,
91      scm_from_utf8_keyword ("use-mip-maps"), &use_mip_maps,
92      SCM_UNDEFINED);
93
94   video::SMaterial* material = new video::SMaterial ();
95   material->MaterialType = scm_to_material_type(material_type);
96   material->AmbientColor = scm_to_color (ambient_color);
97   material->DiffuseColor = scm_to_color (diffuse_color);
98   material->EmissiveColor = scm_to_color (emissive_color);
99   material->SpecularColor = scm_to_color (specular_color);
100   material->Shininess = scm_to_double (shininess);
101   material->MaterialTypeParam = scm_to_double (material_type_param);
102   material->MaterialTypeParam2 = scm_to_double (material_type_param_2);
103   material->Thickness = scm_to_double (thickness);
104   material->ZBuffer = scm_to_comparison_func (z_buffer);
105   material->AntiAliasing = scm_to_anti_aliasing_mode (anti_aliasing);
106   material->ColorMask = scm_to_color_plane (color_mask);
107   material->ColorMaterial = scm_to_color_material (color_material);
108   material->BlendOperation = scm_to_blend_operation (blend_operation);
109   material->PolygonOffsetFactor = scm_to_uint8 (polygon_offset_factor);
110   material->PolygonOffsetDirection = scm_to_polygon_offset (polygon_offset_direction);
111   material->Wireframe = scm_to_bool (wireframe);
112   material->PointCloud = scm_to_bool (point_cloud);
113   material->GouraudShading = scm_to_bool (gouraud_shading);
114   material->Lighting = scm_to_bool (lighting);
115   material->ZWriteEnable = scm_to_bool (z_write_enable);
116   material->BackfaceCulling = scm_to_bool (backface_culling);
117   material->FrontfaceCulling = scm_to_bool (frontface_culling);
118   material->FogEnable = scm_to_bool (fog_enable);
119   material->NormalizeNormals = scm_to_bool (normalize_normals);
120   material->UseMipMaps = scm_to_bool (use_mip_maps);
121   return scm_from_pointer ((void*) material, NULL);
122 }
123
124
125 extern "C" {
126
127   void
128   init_material (void)
129   {
130     DEFINE_GSUBR ("video_SMaterial_make", 0, 0, 1, video_SMaterial_make);
131   }
132
133 }
134
135
136 video::E_ANTI_ALIASING_MODE
137 scm_to_anti_aliasing_mode (SCM anti_aliasing_mode)
138 {
139   char* mode = scm_to_utf8_stringn (scm_symbol_to_string (anti_aliasing_mode), NULL);
140   if (!strcmp (mode, "off"))
141     {
142       return video::EAAM_OFF;
143     }
144   else if (!strcmp (mode, "simple"))
145     {
146       return video::EAAM_SIMPLE;
147     }
148   else if (!strcmp (mode, "quality"))
149     {
150       return video::EAAM_QUALITY;
151     }
152   else if (!strcmp (mode, "line-smooth"))
153     {
154       return video::EAAM_LINE_SMOOTH;
155     }
156   else if (!strcmp (mode, "point-smooth"))
157     {
158       return video::EAAM_POINT_SMOOTH;
159     }
160   else if (!strcmp (mode, "full-basic"))
161     {
162       return video::EAAM_FULL_BASIC;
163     }
164   else if (!strcmp (mode, "alpha-to-coverage"))
165     {
166       return video::EAAM_ALPHA_TO_COVERAGE;
167     }
168   else
169     {
170       scm_error (scm_arg_type_key, NULL, "Wrong anti aliasing mode: ~S",
171                  scm_list_1 (anti_aliasing_mode), scm_list_1 (anti_aliasing_mode));
172     }
173 }
174
175
176 video::E_BLEND_OPERATION
177 scm_to_blend_operation (SCM blend_operation)
178 {
179   char* operation = scm_to_utf8_stringn (scm_symbol_to_string (blend_operation), NULL);
180   if (!strcmp (operation, "none"))
181     {
182       return video::EBO_NONE;
183     }
184   else if (!strcmp (operation, "add"))
185     {
186       return video::EBO_ADD;
187     }
188   else if (!strcmp (operation, "subtract"))
189     {
190       return video::EBO_SUBTRACT;
191     }
192   else if (!strcmp (operation, "rev-subtract"))
193     {
194       return video::EBO_REVSUBTRACT;
195     }
196   else if (!strcmp (operation, "min"))
197     {
198       return video::EBO_MIN;
199     }
200   else if (!strcmp (operation, "max"))
201     {
202       return video::EBO_MAX;
203     }
204   else if (!strcmp (operation, "min-factor"))
205     {
206       return video::EBO_MIN_FACTOR;
207     }
208   else if (!strcmp (operation, "max-factor"))
209     {
210       return video::EBO_MAX_FACTOR;
211     }
212   else if (!strcmp (operation, "min-alpha"))
213     {
214       return video::EBO_MIN_ALPHA;
215     }
216   else if (!strcmp (operation, "max-alpha"))
217     {
218       return video::EBO_MAX_ALPHA;
219     }
220   else
221     {
222       scm_error (scm_arg_type_key, NULL, "Wrong blend operation: ~S",
223                  scm_list_1 (blend_operation), scm_list_1 (blend_operation));
224     }
225 }
226
227
228 video::E_COLOR_MATERIAL
229 scm_to_color_material (SCM color_material)
230 {
231   char* material = scm_to_utf8_stringn (scm_symbol_to_string (color_material), NULL);
232   if (!strcmp (material, "none"))
233     {
234       return video::ECM_NONE;
235     }
236   else if (!strcmp (material, "diffuse"))
237     {
238       return video::ECM_DIFFUSE;
239     }
240   else if (!strcmp (material, "ambient"))
241     {
242       return video::ECM_AMBIENT;
243     }
244   else if (!strcmp (material, "emissive"))
245     {
246       return video::ECM_EMISSIVE;
247     }
248   else if (!strcmp (material, "specular"))
249     {
250       return video::ECM_SPECULAR;
251     }
252   else if (!strcmp (material, "diffuse-and-ambient"))
253     {
254       return video::ECM_DIFFUSE_AND_AMBIENT;
255     }
256   else
257     {
258       scm_error (scm_arg_type_key, NULL, "Wrong color material: ~S",
259                  scm_list_1 (color_material), scm_list_1 (color_material));
260     }
261 }
262
263
264 video::E_COLOR_PLANE
265 scm_to_color_plane (SCM color_plane)
266 {
267   char* plane = scm_to_utf8_stringn (scm_symbol_to_string (color_plane), NULL);
268   if (!strcmp (plane, "none"))
269     {
270       return video::ECP_NONE;
271     }
272   else if (!strcmp (plane, "alpha"))
273     {
274       return video::ECP_ALPHA;
275     }
276   else if (!strcmp (plane, "red"))
277     {
278       return video::ECP_RED;
279     }
280   else if (!strcmp (plane, "green"))
281     {
282       return video::ECP_GREEN;
283     }
284   else if (!strcmp (plane, "blue"))
285     {
286       return video::ECP_BLUE;
287     }
288   else if (!strcmp (plane, "rgb"))
289     {
290       return video::ECP_RGB;
291     }
292   else if (!strcmp (plane, "all"))
293     {
294       return video::ECP_ALL;
295     }
296   else
297     {
298       scm_error (scm_arg_type_key, NULL, "Wrong color plane: ~S",
299                  scm_list_1 (color_plane), scm_list_1 (color_plane));
300     }
301 }
302
303
304 video::E_COMPARISON_FUNC
305 scm_to_comparison_func (SCM comparison_func)
306 {
307   char* func = scm_to_utf8_stringn (scm_symbol_to_string (comparison_func), NULL);
308   if (!strcmp (func, "never"))
309     {
310       return video::ECFN_NEVER;
311     }
312   else if (!strcmp (func, "less-equal"))
313     {
314       return video::ECFN_LESSEQUAL;
315     }
316   else if (!strcmp (func, "equal"))
317     {
318       return video::ECFN_EQUAL;
319     }
320   else if (!strcmp (func, "less"))
321     {
322       return video::ECFN_LESS;
323     }
324   else if (!strcmp (func, "not-equal"))
325     {
326       return video::ECFN_NOTEQUAL;
327     }
328   else if (!strcmp (func, "greater-equal"))
329     {
330       return video::ECFN_GREATEREQUAL;
331     }
332   else if (!strcmp (func, "greater"))
333     {
334       return video::ECFN_GREATER;
335     }
336   else if (!strcmp (func, "always"))
337     {
338       return video::ECFN_ALWAYS;
339     }
340   else
341     {
342       scm_error (scm_arg_type_key, NULL, "Wrong comparison func: ~S",
343                  scm_list_1 (comparison_func), scm_list_1 (comparison_func));
344     }
345 }
346
347
348 video::E_POLYGON_OFFSET
349 scm_to_polygon_offset (SCM polygon_offset)
350 {
351   char* offset = scm_to_utf8_stringn (scm_symbol_to_string (polygon_offset), NULL);
352   if (!strcmp (offset, "back"))
353     {
354       return video::EPO_BACK;
355     }
356   else if (!strcmp (offset, "front"))
357     {
358       return video::EPO_FRONT;
359     }
360   else
361     {
362       scm_error (scm_arg_type_key, NULL, "Wrong polygon offset: ~S",
363                  scm_list_1 (polygon_offset), scm_list_1 (polygon_offset));
364     }
365 }