File: unity.c

package info (click to toggle)
pd-chaos 0.2-3
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 776 kB
  • sloc: ansic: 6,871; makefile: 339
file content (103 lines) | stat: -rw-r--r-- 3,894 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
/* unity Attractor PD External */
/* Copyright Michael McGonagle, from ??????, 2003 */
/* This program is distributed under the params of the GNU Public License */

///////////////////////////////////////////////////////////////////////////////////
/* This file is part of Chaos PD Externals.                                      */
/*                                                                               */
/* Chaos PD Externals are free software; you can redistribute them and/or modify */
/* them under the terms of the GNU General Public License as published by        */
/* the Free Software Foundation; either version 2 of the License, or             */
/* (at your option) any later version.                                           */
/*                                                                               */
/* Chaos PD Externals are distributed in the hope that they will be useful,      */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of                */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                 */
/* GNU General Public License for more details.                                  */
/*                                                                               */
/* You should have received a copy of the GNU General Public License             */
/* along with the Chaos PD Externals; if not, write to the Free Software         */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA     */
///////////////////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include "m_pd.h"



#define M_x 0
#define M_y 1

#define M_param_count 0
#define M_var_count 2
#define M_search_count 0
#define M_failure_limit 1000

static char *version = "unity v0.0, by Michael McGonagle, from ??????, 2003";

t_class *unity_class;

typedef struct unity_struct {
	t_object x_obj;

	double vars[M_var_count];
	double vars_init[M_var_count];
	
	t_outlet *outlets[M_var_count - 1];
} unity_struct;

static void calc(unity_struct *unity, double *vars) {
	double k, x_0, y_0;
	k=(vars[M_x]*vars[M_x])+(vars[M_y]*vars[M_y]);
	x_0 =(2-k)*vars[M_y];
	y_0 =(2-k)*vars[M_x];
	vars[M_x] = x_0;
	vars[M_y] = y_0;
} // end calc

static void calculate(unity_struct *unity) {
	calc(unity, unity -> vars);
	outlet_float(unity -> outlets[M_y - 1], unity -> vars[M_y]);
	outlet_float(unity -> x_obj.ob_outlet, unity -> vars[M_x]);
} // end calculate

static void reset(unity_struct *unity, t_symbol *s, int argc, t_atom *argv) {
	if (argc == M_var_count) {
		unity -> vars[M_x] = (double) atom_getfloatarg(M_x, argc, argv);
		unity -> vars[M_y] = (double) atom_getfloatarg(M_y, argc, argv);
	} else {
		unity -> vars[M_x] = unity -> vars_init[M_x];
		unity -> vars[M_y] = unity -> vars_init[M_y];
	} // end if
} // end reset

void *unity_new(t_symbol *s, int argc, t_atom *argv) {
	unity_struct *unity = (unity_struct *) pd_new(unity_class);
	if (unity != NULL) {
		outlet_new(&unity -> x_obj, &s_float);
		unity -> outlets[0] = outlet_new(&unity -> x_obj, &s_float);
		if (argc == M_param_count + M_var_count) {
			unity -> vars_init[M_x] = unity -> vars[M_x] = (double) atom_getfloatarg(0, argc, argv);
			unity -> vars_init[M_y] = unity -> vars[M_y] = (double) atom_getfloatarg(1, argc, argv);
		} else {
			if (argc != 0 && argc != M_param_count + M_var_count) {
				post("Incorrect number of arguments for unity fractal. Expecting 2 arguments.");
			}
			unity -> vars_init[M_x] = 0;
			unity -> vars_init[M_y] = 0;
		}
	}
	return (void *)unity;
}

void unity_setup(void) {
	unity_class = class_new(gensym("unity"), (t_newmethod) unity_new, 0, sizeof(unity_struct), 0, A_GIMME, 0);
	class_addbang(unity_class, (t_method) calculate);
	class_addmethod(unity_class, (t_method) reset, gensym("reset"), A_GIMME, 0);
	
	
}