void signal_init_globs()
{
int i;
double phaseoffset, d, pmf;
long sz, sz2;
/* setup slopes and wrap masks */
for (i=0; i<32; ++i) {
long length = 1L<<i;
gSlopeFactor[i] = 1./length;
gWrapMask[i] = length - 1;
}
/* fill sine wave */
// pyrmalloc:
// lifetime: forever. initialized at startup.
sineCycle = (float*)pyr_pool_runtime->Alloc((SINESIZE+1) * sizeof(float));
MEMFAIL(sineCycle);
invSineCycle = (float*)pyr_pool_runtime->Alloc((SINESIZE+1) * sizeof(float));
MEMFAIL(invSineCycle);
pmSineCycle = (float*)pyr_pool_runtime->Alloc((SINESIZE+1) * sizeof(float));
MEMFAIL(pmSineCycle);
//gFracTable = (float*)pyr_pool_runtime->Alloc(FRACTABLESIZE * sizeof(float));
//MEMFAIL(gFracTable);
sineIndexToPhase = 2. * 3.1415926535897932384626433832795 / SINESIZE;
phaseToSineIndex = 1. / sineIndexToPhase;
phaseoffset = sineIndexToPhase * 0.5;
pmf = (1L << 29) / twopi;
for (i=0; i<=SINESIZE; ++i) {
double phase;
phase = i * sineIndexToPhase;
sineCycle[i] = d = sin(phase);
invSineCycle[i] = 1. / d;
pmSineCycle[i] = d * pmf;
}
// fix 1/0 values to a special large number
invSineCycle[0] = invSineCycle[SINESIZE/2] = invSineCycle[SINESIZE] = VERY_BIG_FLOAT;
sz = SINESIZE;
sz2 = sz>>1;
for (i=1; i<=8; ++i) {
//for (i=1; i<=0; ++i) { //ie. none
//postfl("%d %f %f\n", i, invSineCycle[i], sineCycle[i]);
invSineCycle[i] = invSineCycle[sz-i] = VERY_BIG_FLOAT;
invSineCycle[sz2-i] = invSineCycle[sz2+i] = VERY_BIG_FLOAT;
}
/*fracscale = 1./FRACTABLESIZE;
for (i=0; i<FRACTABLESIZE; ++i) {
gFracTable[i] = (double)i * fracscale;
}*/
}
void startLexerCmdLine(char *textbuf, int textbuflen)
{
// pyrmalloc:
// lifetime: kill after compile. (this one gets killed anyway)
text = (char*)pyr_pool_compile->Alloc((textbuflen+2) * sizeof(char));
MEMFAIL(text);
memcpy(text, textbuf, textbuflen);
text[textbuflen] = ' ';
text[textbuflen+1] = 0;
textlen = textbuflen + 1;
rtf2txt(text);
initLongStack(&brackets);
initLongStack(&closedFuncCharNo);
initLongStack(&generatorStack);
lastClosedFuncCharNo = 0;
textpos = 0;
linepos = 0;
lineno = 1;
charno = 0;
yylen = 0;
zzval = 0;
parseFailed = 0;
lexCmdLine = 1;
strcpy(curfilename, "selected text");
maxlinestarts = 1000;
linestarts = (int*)pyr_pool_compile->Alloc(maxlinestarts * sizeof(int*));
linestarts[0] = 0;
linestarts[1] = 0;
errLineOffset = 0;
errCharPosOffset = 0;
}
ClassDependancy* newClassDependancy(PyrSymbol *className, PyrSymbol *superClassName,
PyrSymbol *fileSym, int startPos, int endPos, int lineOffset)
{
ClassDependancy* classdep;
//post("classdep '%s' '%s' '%s' %d %d\n", className->name, superClassName->name,
// fileSym->name, className, superClassName);
// pyrmalloc:
// lifetime: kill after compile.
numClassDeps++;
if (className->classdep) {
error("duplicate Class found: '%s' \n", className->name);
post("%s\n",className->classdep->fileSym->name);
postfl("%s\n\n",fileSym->name);
return className->classdep;
}
classdep = (ClassDependancy*)pyr_pool_compile->Alloc(sizeof(ClassDependancy));
MEMFAIL(text);
classdep->className = className;
classdep->superClassName = superClassName;
classdep->fileSym = fileSym;
classdep->superClassDep = NULL;
classdep->next = NULL;
classdep->subclasses = NULL;
classdep->startPos = startPos;
classdep->endPos = endPos;
classdep->lineOffset = lineOffset;
className->classdep = classdep;
return classdep;
}
int prSpeakText(struct VMGlobals *g, int numArgsPushed){
OSErr theErr = noErr;
PyrSlot *obj = g->sp-2;
PyrSlot *a = g->sp-1;
PyrSlot *str = g->sp;
int chan;
slotIntVal(a, &chan);
chan = sc_clip(chan, 0, kMaxSpeechChannels);
if(speechStrings[chan] != NULL) {
post("voice %i already speaking\n", chan);
return errNone;
} else {
// speechStrings[chan] = (char*)pyr_pool_compile->Alloc((a->uo->size + 1)* sizeof(char));
speechStrings[chan] = (char*) malloc((str->uo->size + 1)* sizeof(char));
MEMFAIL(speechStrings[chan]);
slotStrVal(str, speechStrings[chan], str->uo->size+1);
//if(!fCurSpeechChannel) theErr = NewSpeechChannel( NULL, &fCurSpeechChannel );
theErr = SpeakText( fCurSpeechChannel[chan], speechStrings[chan], strlen(speechStrings[chan]));
//should be freed only after the text was spoken!
// todo move this bit to the callback!
// pyr_pool_compile->Free(theTextToSpeak);
}
return errNone;
}
int audio_pa_run(audio_callback_fn_pt callback, double sample_rate, unsigned long chunk_size) {
chunk = calloc(chunk_size, sizeof *chunk);
if(chunk == NULL) MEMFAIL();
PaError err = Pa_Initialize();
if(err != paNoError) FAIL("Could not initialize PortAudio\n");
PaStreamParameters inputParameters;
inputParameters.device = Pa_GetDefaultInputDevice();
inputParameters.channelCount = NUM_CHANNELS;
inputParameters.sampleFormat = PA_SAMPLE_TYPE;
inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputParameters.device )->defaultHighInputLatency ;
inputParameters.hostApiSpecificStreamInfo = NULL;
PaStream *stream = NULL;
err = Pa_OpenStream(&stream,
&inputParameters,
0,
sample_rate,
chunk_size,
paClipOff,
0,
0);
if(err != paNoError) FAIL("Could not open PortAudio input stream\n");
err = Pa_StartStream(stream);
if(err != paNoError) FAIL("Could not open audio input stream\n");
/*
printf("Gracefully terminated PortAudio\n");
*/
int cb_err = 0;
while(cb_err == 0){
err = Pa_ReadStream(stream, chunk, chunk_size );
if(err != paNoError) FAIL("Could not read audio chunk\n");
cb_err = callback(chunk);
}
err = Pa_Terminate();
if(err != paNoError) FAIL("Could not terminate PortAudio\n");
free(chunk);
return 0;
}
void traverseFullDepTree()
{
//postfl("->traverseFullDepTree\n"); fflush(stdout);
gClassCompileOrderNum = 0;
gClassCompileOrder = (ClassDependancy**)pyr_pool_compile->Alloc(
gClassCompileOrderSize * sizeof(ClassDependancy));
MEMFAIL(gClassCompileOrder);
// parse and compile all files
initParser(); // sets compiler errors to 0
gParserResult = -1;
traverseDepTree(s_object->classdep, 0);
compileDepTree(); // compiles backwards using the order defined in gClassCompileOrder
compileClassExtensions();
pyr_pool_compile->Free(gClassCompileOrder);
finiParser();
//postfl("<-traverseFullDepTree\n"); fflush(stdout);
}
void traverseDepTree(ClassDependancy *classdep, int level)
{
ClassDependancy *subclassdep;
if (!classdep) return;
subclassdep = classdep->subclasses;
for (; subclassdep; subclassdep = subclassdep->next) {
traverseDepTree(subclassdep, level+1);
}
if (gClassCompileOrderNum > gClassCompileOrderSize) {
gClassCompileOrderSize *= 2;
gClassCompileOrder = (ClassDependancy**)pyr_pool_compile->Realloc(gClassCompileOrder,
gClassCompileOrderSize * sizeof(ClassDependancy));
MEMFAIL(gClassCompileOrder);
}
/* postfl("traverse level:%d, gClassCompileOrderNum:%d, '%s' '%s' '%s'\n", level, gClassCompileOrderNum, classdep->className->name, classdep->superClassName->name,
classdep->fileSym->name); fflush(stdout);
*/
gClassCompileOrder[gClassCompileOrderNum++] = classdep;
}
static bool getFileText(char* filename, char **text, int *length)
{
FILE *file;
char *ltext;
int llength;
#ifdef SC_WIN32
file = fopen(filename, "rb");
#else
file = fopen(filename, "r");
#endif
if (!file) return false;
fseek(file, 0L, SEEK_END);
llength = ftell(file);
fseek(file, 0L, SEEK_SET);
ltext = (char*)pyr_pool_compile->Alloc((llength+1) * sizeof(char));
#ifdef SC_WIN32
// win32 isprint( ) doesn't like the 0xcd after the end of file when
// there is a mismatch in lengths due to line endings....
memset(ltext,0,(llength+1) * sizeof(char));
#endif //SC_WIN32
MEMFAIL(ltext);
size_t size = fread(ltext, 1, llength, file);
if (size != llength) {
error("error when reading file");
fclose(file);
return false;
}
ltext[llength] = 0;
//ltext[llength] = 0;
*length = llength;
fclose(file);
*text = ltext;
return true;
}
void ui_init() {
// Init SDL
if(SDL_Init(SDL_INIT_VIDEO) < 0) FAIL("SDL could not initialize! SDL Error: %s\n", SDL_GetError());
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
ww = config.ui.window_width;
wh = config.ui.window_height;
window = SDL_CreateWindow("Radiance", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, ww, wh, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);
if(window == NULL) FAIL("Window could not be created: %s\n", SDL_GetError());
context = SDL_GL_CreateContext(window);
if(context == NULL) FAIL("OpenGL context could not be created: %s\n", SDL_GetError());
if(SDL_GL_SetSwapInterval(1) < 0) fprintf(stderr, "Warning: Unable to set VSync: %s\n", SDL_GetError());
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
if(renderer == NULL) FAIL("Could not create renderer: %s\n", SDL_GetError());
if(TTF_Init() < 0) FAIL("Could not initialize font library: %s\n", TTF_GetError());
// Init OpenGL
GLenum e;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClearColor(0, 0, 0, 0);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
// Make framebuffers
glGenFramebuffersEXT(1, &select_fb);
glGenFramebuffersEXT(1, &pat_fb);
glGenFramebuffersEXT(1, &crossfader_fb);
glGenFramebuffersEXT(1, &pat_entry_fb);
glGenFramebuffersEXT(1, &spectrum_fb);
glGenFramebuffersEXT(1, &waveform_fb);
glGenFramebuffersEXT(1, &strip_fb);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
// Init select texture
glGenTextures(1, &select_tex);
glBindTexture(GL_TEXTURE_2D, select_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ww, wh, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, select_fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, select_tex, 0);
// Init pattern textures
pattern_textures = calloc(config.ui.n_patterns, sizeof(GLuint));
if(pattern_textures == NULL) MEMFAIL();
pattern_name_textures = calloc(config.ui.n_patterns, sizeof(SDL_Texture *));
pattern_name_width = calloc(config.ui.n_patterns, sizeof(int));
pattern_name_height = calloc(config.ui.n_patterns, sizeof(int));
if(pattern_name_textures == NULL || pattern_name_width == NULL || pattern_name_height == NULL) MEMFAIL();
glGenTextures(config.ui.n_patterns, pattern_textures);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
for(int i = 0; i < config.ui.n_patterns; i++) {
glBindTexture(GL_TEXTURE_2D, pattern_textures[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.ui.pattern_width, config.ui.pattern_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
// Init crossfader texture
glGenTextures(1, &crossfader_texture);
glBindTexture(GL_TEXTURE_2D, crossfader_texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.ui.crossfader_width, config.ui.crossfader_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, crossfader_fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, crossfader_texture, 0);
// Init pattern entry texture
glGenTextures(1, &pat_entry_texture);
glBindTexture(GL_TEXTURE_2D, pat_entry_texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.ui.pat_entry_width, config.ui.pat_entry_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, pat_entry_fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, pat_entry_texture, 0);
// Spectrum data texture
glGenTextures(1, &tex_spectrum_data);
glBindTexture(GL_TEXTURE_1D, tex_spectrum_data);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage1D(GL_TEXTURE_1D, 0, GL_R32F, config.audio.spectrum_bins, 0, GL_RED, GL_FLOAT, NULL);
// Spectrum UI element
glGenTextures(1, &spectrum_texture);
glBindTexture(GL_TEXTURE_2D, spectrum_texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.ui.spectrum_width, config.ui.spectrum_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, spectrum_fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, spectrum_texture, 0);
// Waveform data texture
glGenTextures(1, &tex_waveform_data);
glBindTexture(GL_TEXTURE_1D, tex_waveform_data);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA32F, config.audio.waveform_length, 0, GL_RGBA, GL_FLOAT, NULL);
glGenTextures(1, &tex_waveform_beats_data);
glBindTexture(GL_TEXTURE_1D, tex_waveform_beats_data);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA32F, config.audio.waveform_length, 0, GL_RGBA, GL_FLOAT, NULL);
// Waveform UI element
glGenTextures(1, &waveform_texture);
glBindTexture(GL_TEXTURE_2D, waveform_texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.ui.waveform_width, config.ui.waveform_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, waveform_fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, waveform_texture, 0);
// Strip indicators
glGenTextures(1, &strip_texture);
glBindTexture(GL_TEXTURE_2D, strip_texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.pattern.master_width, config.pattern.master_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, strip_fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, strip_texture, 0);
// Done allocating textures & FBOs, unbind and check for errors
glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
if((blit_shader = load_shader("resources/blit.glsl")) == 0) FAIL("Could not load blit shader!\n%s", load_shader_error);
if((main_shader = load_shader("resources/ui_main.glsl")) == 0) FAIL("Could not load UI main shader!\n%s", load_shader_error);
if((pat_shader = load_shader("resources/ui_pat.glsl")) == 0) FAIL("Could not load UI pattern shader!\n%s", load_shader_error);
if((crossfader_shader = load_shader("resources/ui_crossfader.glsl")) == 0) FAIL("Could not load UI crossfader shader!\n%s", load_shader_error);
if((text_shader = load_shader("resources/ui_text.glsl")) == 0) FAIL("Could not load UI text shader!\n%s", load_shader_error);
if((spectrum_shader = load_shader("resources/ui_spectrum.glsl")) == 0) FAIL("Could not load UI spectrum shader!\n%s", load_shader_error);
if((waveform_shader = load_shader("resources/ui_waveform.glsl")) == 0) FAIL("Could not load UI waveform shader!\n%s", load_shader_error);
if((strip_shader = load_shader("resources/strip.glsl")) == 0) FAIL("Could not load strip indicator shader!\n%s", load_shader_error);
// Stop text input
SDL_StopTextInput();
// Open the font
font = TTF_OpenFont(config.ui.font, config.ui.fontsize);
if(font == NULL) FAIL("Could not open font %s: %s\n", config.ui.font, SDL_GetError());
// Init statics
pat_entry = false;
SDL_Surface * surf;
surf = TTF_RenderText_Blended(font, "wtf, why is this necessary", font_color);
if(surf == NULL) FAIL("Could not create surface: %s\n", SDL_GetError());
SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, surf);
if(texture == NULL) FAIL("Could not create texture: %s\n", SDL_GetError());
SDL_FreeSurface(surf);
SDL_DestroyTexture(texture);
}
void* pyr_new_area_from_runtime(size_t size)
{
void *ptr = pyr_pool_runtime->Alloc(size);
MEMFAIL(ptr);
return ptr;
}
int pattern_init(struct pattern * pattern, const char * prefix) {
GLenum e;
memset(pattern, 0, sizeof *pattern);
pattern->intensity = 0;
pattern->intensity_integral = 0;
pattern->name = strdup(prefix);
if(pattern->name == NULL) ERROR("Could not allocate memory");
int n = 0;
for(;;) {
char * filename;
struct stat statbuf;
filename = rsprintf("%s%s.%d.glsl", config.pattern.dir, prefix, n);
if(filename == NULL) MEMFAIL();
int rc = stat(filename, &statbuf);
free(filename);
if (rc != 0 || S_ISDIR(statbuf.st_mode)) {
break;
}
n++;
}
if(n == 0) {
ERROR("Could not find any shaders for %s", prefix);
return 1;
}
pattern->n_shaders = n;
pattern->shader = calloc(pattern->n_shaders, sizeof *pattern->shader);
if(pattern->shader == NULL) MEMFAIL();
pattern->tex = calloc(pattern->n_shaders, sizeof *pattern->tex);
if(pattern->tex == NULL) MEMFAIL();
bool success = true;
for(int i = 0; i < pattern->n_shaders; i++) {
char * filename;
filename = rsprintf("%s%s.%d.glsl", config.pattern.dir, prefix, i);
if(filename == NULL) MEMFAIL();
GLhandleARB h = load_shader(filename);
if (h == 0) {
fprintf(stderr, "%s", load_shader_error);
WARN("Unable to load shader %s", filename);
success = false;
} else {
pattern->shader[i] = h;
DEBUG("Loaded shader #%d", i);
}
free(filename);
}
if(!success) {
ERROR("Failed to load some shaders.");
return 2;
}
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
// Render targets
glGenFramebuffersEXT(1, &pattern->fb);
glGenTextures(pattern->n_shaders + 1, pattern->tex);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
for(int i = 0; i < pattern->n_shaders + 1; i++) {
glBindTexture(GL_TEXTURE_2D, pattern->tex[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.pattern.master_width, config.pattern.master_height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
glBindTexture(GL_TEXTURE_2D, 0);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, pattern->fb);
for(int i = 0; i < pattern->n_shaders + 1; i++) {
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D,
pattern->tex[i], 0);
glClear(GL_COLOR_BUFFER_BIT);
}
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
// Some OpenGL API garbage
pattern->uni_tex = calloc(pattern->n_shaders, sizeof *pattern->uni_tex);
if(pattern->uni_tex == NULL) MEMFAIL();
for(int i = 0; i < pattern->n_shaders; i++) {
pattern->uni_tex[i] = i + 1;
}
return 0;
}
