/**
* Returns 4 values for Simplex noise at a 2D location.
*/
VuoPoint4d VuoGradientNoise_simplex_VuoPoint2d_VuoPoint4d(VuoPoint2d point)
{
return VuoPoint4d_make(VuoGradientNoise_simplex_VuoPoint2d_VuoReal(VuoPoint2d_add(point,VuoPoint2d_make(-1,-1))),
VuoGradientNoise_simplex_VuoPoint2d_VuoReal(point),
VuoGradientNoise_simplex_VuoPoint2d_VuoReal(VuoPoint2d_add(point,VuoPoint2d_make(1,1))),
VuoGradientNoise_simplex_VuoPoint2d_VuoReal(VuoPoint2d_add(point,VuoPoint2d_make(2,2))));
}
struct nodeInstanceData * nodeInstanceInit(void)
{
struct nodeInstanceData * instance = (struct nodeInstanceData *)malloc(sizeof(struct nodeInstanceData));
VuoRegister(instance, free);
instance->glContext = VuoGlContext_use();
instance->imageRenderer = VuoImageRenderer_make(instance->glContext);
VuoRetain(instance->imageRenderer);
VuoList_VuoColor colors = VuoListCreate_VuoColor();
VuoRetain(colors);
instance->shader = VuoShader_makeRadialGradientShader(colors, VuoPoint2d_make(0., 0.), 1., 1., 1.);
VuoRetain(instance->shader);
VuoRelease(colors);
return instance;
}
/**
* Returns 2 values for Simplex noise at a 4D location.
*/
VuoPoint2d VuoGradientNoise_simplex_VuoPoint4d_VuoPoint2d(VuoPoint4d point)
{
return VuoPoint2d_make(VuoGradientNoise_simplex_VuoPoint4d_VuoReal(point),
VuoGradientNoise_simplex_VuoPoint4d_VuoReal(VuoPoint4d_multiply(point,-1)));
}
/**
* Returns 2 values for Simplex noise at a 1D location.
*/
VuoPoint2d VuoGradientNoise_simplex_VuoReal_VuoPoint2d(VuoReal x)
{
return VuoPoint2d_make(VuoGradientNoise_simplex_VuoReal_VuoReal(x),
VuoGradientNoise_simplex_VuoReal_VuoReal(x+1));
}
/**
* Returns 2 values for Perlin noise at a 3D location.
*/
VuoPoint2d VuoGradientNoise_perlin_VuoPoint3d_VuoPoint2d(VuoPoint3d point)
{
return VuoPoint2d_make(VuoGradientNoise_perlin_VuoPoint3d_VuoReal(point),
VuoGradientNoise_perlin_VuoPoint3d_VuoReal(VuoPoint3d_multiply(point,-1)));
}
/**
* Returns 3 values for Perlin noise at a 2D location.
*/
VuoPoint3d VuoGradientNoise_perlin_VuoPoint2d_VuoPoint3d(VuoPoint2d point)
{
return VuoPoint3d_make(VuoGradientNoise_perlin_VuoPoint2d_VuoReal(VuoPoint2d_add(point,VuoPoint2d_make(-1,-1))),
VuoGradientNoise_perlin_VuoPoint2d_VuoReal(point),
VuoGradientNoise_perlin_VuoPoint2d_VuoReal(VuoPoint2d_add(point,VuoPoint2d_make(1,1))));
}
/**
* Returns 2 values for Perlin noise at a 1D location.
*/
VuoPoint2d VuoGradientNoise_perlin_VuoReal_VuoPoint2d(VuoReal x)
{
return VuoPoint2d_make(VuoGradientNoise_perlin_VuoReal_VuoReal(x),
VuoGradientNoise_perlin_VuoReal_VuoReal(x+1));
}
/**
* @file
* vuo.type.rotate.real.transform2d node implementation.
*
* @copyright Copyright © 2012–2015 Kosada Incorporated.
* This code may be modified and distributed under the terms of the MIT License.
* For more information, see http://vuo.org/license.
*/
#include "node.h"
VuoModuleMetadata({
"title" : "Convert Real to Rotation",
"keywords" : [ "rotate", "matrix", "trs", "angle", "roll", "axis" ],
"version" : "1.0.0"
});
void nodeEvent
(
VuoInputData(VuoReal, {"default":0.0,"suggestedMin":0.0,"suggestedMax":360.0,"suggestedStep":15.0}) rotation,
VuoOutputData(VuoTransform2d) transform
)
{
// 2d transform stores rotation as a radian, and the constructor doesn't convert for ye'
*transform = VuoTransform2d_make(VuoPoint2d_make(0,0), rotation * M_PI/180., VuoPoint2d_make(1,1));
}
/**
* @file
* vuo.type.translate.point2d.transform2d node implementation.
*
* @copyright Copyright © 2012–2015 Kosada Incorporated.
* This code may be modified and distributed under the terms of the MIT License.
* For more information, see http://vuo.org/license.
*/
#include "node.h"
VuoModuleMetadata({
"title" : "Convert 2D Point to Translation",
"keywords" : [ "position", "matrix", "trs", "angle", "axis" ],
"version" : "1.0.0"
});
void nodeEvent
(
VuoInputData(VuoPoint2d, {"default":{"x":1, "y":1}}) translation,
VuoOutputData(VuoTransform2d) transform
)
{
*transform = VuoTransform2d_make(translation, 0., VuoPoint2d_make(1,1));
}
/**
* @file
* vuo.type.integer.point2d node implementation.
*
* @copyright Copyright © 2012–2014 Kosada Incorporated.
* This code may be modified and distributed under the terms of the MIT License.
* For more information, see http://vuo.org/license.
*/
#include "node.h"
VuoModuleMetadata({
"title" : "Convert Integer to 2D Point",
"keywords" : [ ],
"version" : "1.0.0"
});
void nodeEvent
(
VuoInputData(VuoInteger, {"default":0}) x,
VuoOutputData(VuoPoint2d) point2d
)
{
*point2d = VuoPoint2d_make(x, 0);
}
}
void nodeInstanceEvent
(
VuoInstanceData(struct nodeInstanceData *) instance,
VuoInputData(VuoList_VuoColor, {"default":[{"r":1,"g":1,"b":1,"a":1}, {"r":0,"g":0,"b":0,"a":1}]}) colors,
// VuoInputEvent({"eventBlocking":"none","data":"colors"}) colorsEvent,
VuoInputData(VuoPoint2d, {"default":{"x":0,"y":0}, "suggestedStep":{"x":0.1,"y":0.1}}) center,
VuoInputData(VuoReal, {"default":1, "suggestedMin":0, "suggestedStep":0.1}) radius,
VuoInputData(VuoInteger, {"default":640, "suggestedMin":1, "suggestedStep":32}) width,
VuoInputData(VuoInteger, {"default":480, "suggestedMin":1, "suggestedStep":32}) height,
VuoOutputData(VuoImage) image
)
{
// VuoPoint2d scale = width < height ? VuoPoint2d_make(1., height/(float)width) : VuoPoint2d_make(width/(float)height, 1.);
VuoPoint2d scale = VuoPoint2d_make(1., height/(float)width);
int len = VuoListGetCount_VuoColor(colors);
unsigned char* pixels = (unsigned char*)malloc(sizeof(char)*len*4);
int n = 0;
for(int i = 1; i <= len; i++)
{
VuoColor col = VuoListGetValue_VuoColor(colors, i);
pixels[n++] = (unsigned int)(col.a*col.r*255);
pixels[n++] = (unsigned int)(col.a*col.g*255);
pixels[n++] = (unsigned int)(col.a*col.b*255);
pixels[n++] = (unsigned int)(col.a*255);
}
VuoImage gradientStrip = VuoImage_makeFromBuffer(pixels, GL_RGBA, len, 1, VuoImageColorDepth_8);
/**
* Returns a pseudorandom value where each component is between `minimum` and `maximum`.
*
* @see VuoInteger_randomWithState
*/
VuoPoint2d VuoPoint2d_randomWithState(unsigned short state[3], const VuoPoint2d minimum, const VuoPoint2d maximum)
{
return VuoPoint2d_make(
VuoReal_randomWithState(state, minimum.x, maximum.x),
VuoReal_randomWithState(state, minimum.y, maximum.y));
}
/**
* Returns a pseudorandom value where each component is between `minimum` and `maximum`.
*
* @see VuoInteger_random
*/
VuoPoint2d VuoPoint2d_random(const VuoPoint2d minimum, const VuoPoint2d maximum)
{
return VuoPoint2d_make(
VuoReal_random(minimum.x, maximum.x),
VuoReal_random(minimum.y, maximum.y));
}
/**
* @file
* vuo.type.scale.point2d.transform2d node implementation.
*
* @copyright Copyright © 2012–2014 Kosada Incorporated.
* This code may be modified and distributed under the terms of the MIT License.
* For more information, see http://vuo.org/license.
*/
#include "node.h"
VuoModuleMetadata({
"title" : "Convert 2D Point to Scale",
"keywords" : [ "matrix", "trs", "size", "angle", "axis", "grow", "shrink", "stretch" ],
"version" : "1.0.0"
});
void nodeEvent
(
VuoInputData(VuoPoint2d, {"default":{"x":1, "y":1}}) scale,
VuoOutputData(VuoTransform2d) transform
)
{
*transform = VuoTransform2d_make(VuoPoint2d_make(0,0), 0., scale);
}