├── Readme.txt
├── .gitignore
├── Thumbnail.jpg
├── audio
    ├── 4klang.mp3
    ├── 4klang.h
    ├── 4klang.inc
    └── 4klang.asm
├── scripts
    ├── directories.js
    ├── .eslintrc.yml
    ├── spawn-promise.js
    ├── convert.js
    └── build.js
├── shaders
    ├── beat.stoy
    ├── shader.preset
    ├── shader.glsl
    └── shader.stoy
├── src
    ├── window.hpp
    ├── audio.hpp
    ├── time.hpp
    ├── gl.hpp
    ├── shots.hpp
    └── intro.cpp
├── package.json
├── config.yml
└── Readme.md


/Readme.txt:
--------------------------------------------------------------------------------
1 | Those Who Leave
2 | by Koltes, Ponk, Unix
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .settings/
2 | build/
3 | dist/
4 | node_modules/
5 | .cproject
6 | .project
7 | 


--------------------------------------------------------------------------------
/Thumbnail.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KoltesDigital/Those-Who-Leave/HEAD/Thumbnail.jpg


--------------------------------------------------------------------------------
/audio/4klang.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KoltesDigital/Those-Who-Leave/HEAD/audio/4klang.mp3


--------------------------------------------------------------------------------
/scripts/directories.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | exports.audioDirectory = 'audio';
4 | exports.buildDirectory = 'build';
5 | exports.distDirectory = 'dist';
6 | exports.shadersDirectory = 'shaders';
7 | exports.srcDirectory = 'src';
8 | 


--------------------------------------------------------------------------------
/shaders/beat.stoy:
--------------------------------------------------------------------------------
 1 | uniform float synth_Time;
 2 | uniform float BPM; //! slider[10, 100, 200]
 3 | #define Beat (synth_Time*BPM/60.)
 4 | 
 5 | // begin
 6 | 
 7 | void main() {
 8 | 	gl_FragColor = vec4(fract(Beat));
 9 | }
10 | 


--------------------------------------------------------------------------------
/scripts/.eslintrc.yml:
--------------------------------------------------------------------------------
 1 | env:
 2 |   es6: true
 3 |   node: true
 4 | extends: 'eslint:recommended'
 5 | rules:
 6 |   indent:
 7 |     - error
 8 |     - tab
 9 |   no-console: off
10 |   quotes:
11 |     - error
12 |     - single
13 |   semi:
14 |     - error
15 |     - always
16 | 


--------------------------------------------------------------------------------
/src/window.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static const PIXELFORMATDESCRIPTOR pfd = {
 4 | 	sizeof(PIXELFORMATDESCRIPTOR),
 5 | 	1,
 6 | 	PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
 7 | 	PFD_TYPE_RGBA,
 8 | 	32,
 9 | 	0,
10 | 	0,
11 | 	0,
12 | 	0,
13 | 	0,
14 | 	0,
15 | 	8,
16 | 	0,
17 | 	0,
18 | 	0,
19 | 	0,
20 | 	0,
21 | 	0,
22 | 	32,
23 | 	0,
24 | 	0,
25 | 	PFD_MAIN_PLANE,
26 | 	0,
27 | 	0,
28 | 	0,
29 | 	0,
30 | };
31 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "private": true,
 3 |   "name": "flower",
 4 |   "version": "1.0.0",
 5 |   "description": "4k for evoke 2017.",
 6 |   "main": "build-shader-header.js",
 7 |   "scripts": {
 8 |     "build": "node scripts/build.js",
 9 |     "convert": "node scripts/convert.js",
10 |     "watch": "nodemon -e cpp,h,hpp,js,preset,stoy,yml -i build scripts/build.js"
11 |   },
12 |   "dependencies": {
13 |     "glsl-unit": "^0.0.7",
14 |     "js-yaml": "^3.9.1",
15 |     "make-dir": "^1.0.0",
16 |     "node-notifier": "^5.1.2",
17 |     "nodemon": "^1.11.0",
18 |     "rimraf-promise": "^2.0.0"
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/scripts/spawn-promise.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const { spawn } = require('child_process');
 4 | 
 5 | module.exports = function(command, args, options) {
 6 | 	return new Promise((resolve, reject) => {
 7 | 		const cp = spawn(command, args, options);
 8 | 
 9 | 		cp.stdout.on('data', (data) => {
10 | 			console.log(data.toString());
11 | 		});
12 | 
13 | 		cp.stderr.on('data', (data) => {
14 | 			console.error(data.toString());
15 | 		});
16 | 
17 | 		cp.on('close', (code, signal) => {
18 | 			if (code)
19 | 				return reject(new Error(command + ' exited with code ' + code + '.'));
20 | 			else if (signal)
21 | 				return reject(new Error(command + ' was stopped by signal ' + signal + '.'));
22 | 			else
23 | 				return resolve();
24 | 		});
25 | 	});
26 | };
27 | 


--------------------------------------------------------------------------------
/src/audio.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static SAMPLE_TYPE soundBuffer[MAX_SAMPLES * 2];
 4 | static HWAVEOUT waveOut;
 5 | 
 6 | #pragma data_seg(".wavefmt")
 7 | static const WAVEFORMATEX waveFormat = {
 8 | #ifdef FLOAT_32BIT
 9 | 	WAVE_FORMAT_IEEE_FLOAT,
10 | #else
11 | 	WAVE_FORMAT_PCM,
12 | #endif
13 | 	2,									   // channels
14 | 	SAMPLE_RATE,						   // samples per sec
15 | 	SAMPLE_RATE * sizeof(SAMPLE_TYPE) * 2, // bytes per sec
16 | 	sizeof(SAMPLE_TYPE) * 2,			   // block alignment;
17 | 	sizeof(SAMPLE_TYPE) * 8,			   // bits per sample
18 | 	0,									   // extension not needed
19 | };
20 | 
21 | #pragma data_seg(".wavehdr")
22 | static WAVEHDR waveHDR = {
23 | 	(LPSTR)soundBuffer,
24 | 	MAX_SAMPLES * sizeof(SAMPLE_TYPE) * 2, // MAX_SAMPLES*sizeof(float)*2(stereo)
25 | 	0,
26 | 	0,
27 | 	0,
28 | 	0,
29 | 	0,
30 | 	0,
31 | };
32 | 
33 | static MMTIME mmTime = {
34 | 	TIME_SAMPLES,
35 | 	0,
36 | };
37 | 


--------------------------------------------------------------------------------
/config.yml:
--------------------------------------------------------------------------------
 1 | # capture:
 2 | #   width: 1280
 3 | #   height: 720
 4 | #   fps: 30
 5 | #   duration: 128
 6 | constantsPreset: Default
 7 | distFile: those-who-leave-by-koltes-ponk-unix/those-who-leave.exe
 8 | # forceResolution:
 9 | #   width: 1920
10 | #   height: 1080
11 | globals:
12 |   float:
13 |   - currentHeight
14 |   - hash
15 |   - stepIndex
16 |   - TAU = 6.283
17 | shaderFile: shader.stoy
18 | uniforms:
19 |   - Beat
20 |   - EndCameraAnglesX
21 |   - EndCameraAnglesY
22 |   - EndCameraAnglesZ
23 |   - EndCameraPositionX
24 |   - EndCameraPositionY
25 |   - EndCameraPositionZ
26 |   - EndSeedPositionX
27 |   - EndSeedPositionY
28 |   - EndSeedPositionZ
29 |   - StartCameraAnglesX
30 |   - StartCameraAnglesY
31 |   - StartCameraAnglesZ
32 |   - StartCameraPositionX
33 |   - StartCameraPositionY
34 |   - StartCameraPositionZ
35 |   - StartSeedPositionX
36 |   - StartSeedPositionY
37 |   - StartSeedPositionZ
38 |   - StartEndRatio
39 | 


--------------------------------------------------------------------------------
/audio/4klang.h:
--------------------------------------------------------------------------------
 1 | // some useful song defines for 4klang
 2 | #define SAMPLE_RATE 44100
 3 | #define BPM 100.000000
 4 | #define MAX_INSTRUMENTS 5
 5 | #define MAX_PATTERNS 53
 6 | #define PATTERN_SIZE_SHIFT 4
 7 | #define PATTERN_SIZE (1 << PATTERN_SIZE_SHIFT)
 8 | #define MAX_TICKS (MAX_PATTERNS*PATTERN_SIZE)
 9 | #define SAMPLES_PER_TICK 6615
10 | #define MAX_SAMPLES (SAMPLES_PER_TICK*MAX_TICKS)
11 | #define POLYPHONY 2
12 | #define FLOAT_32BIT
13 | #define SAMPLE_TYPE float
14 | 
15 | #define WINDOWS_OBJECT
16 | 
17 | // declaration of the external synth render function, you'll always need that
18 | extern "C" void  __stdcall	_4klang_render(void*);
19 | // declaration of the external envelope buffer. access only if you're song was exported with that option
20 | extern "C" float _4klang_envelope_buffer;
21 | // declaration of the external note buffer. access only if you're song was exported with that option
22 | extern "C" int   _4klang_note_buffer;
23 | 


--------------------------------------------------------------------------------
/scripts/convert.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const { audioDirectory, distDirectory } = require('./directories');
 4 | const { readFileSync } = require('fs');
 5 | const { safeLoad } = require('js-yaml');
 6 | const { dirname, join } = require('path');
 7 | const spawnPromise = require('./spawn-promise');
 8 | 
 9 | const config = safeLoad(readFileSync('config.yml'));
10 | 
11 | spawnPromise('ffmpeg', [
12 | 	'-y',
13 | 	'-f',
14 | 	'image2',
15 | 	'-r',
16 | 	config.capture.fps,
17 | 	'-s',
18 | 	config.capture.width + 'x' + config.capture.height,
19 | 	'-pix_fmt',
20 | 	'rgb24',
21 | 	'-start_number',
22 | 	'0',
23 | 	'-i',
24 | 	join(distDirectory, dirname(config.distFile), 'frame%05d.raw'),
25 | 	'-i',
26 | 	join(audioDirectory, '4klang.mp3'),
27 | 	'-vf',
28 | 	'vflip',
29 | 	'-codec:v',
30 | 	'libx264',
31 | 	'-crf',
32 | 	'18',
33 | 	'-bf',
34 | 	'2',
35 | 	'-flags',
36 | 	'+cgop',
37 | 	'-pix_fmt',
38 | 	'yuv420p',
39 | 	'-codec:a',
40 | 	'aac',
41 | 	'-strict',
42 | 	'-2',
43 | 	'-b:a',
44 | 	'384k',
45 | 	'-movflags',
46 | 	'faststart',
47 | 	join(distDirectory, 'intro.mp4'),
48 | ])
49 | .catch(console.error);
50 | 


--------------------------------------------------------------------------------
/Readme.md:
--------------------------------------------------------------------------------
 1 | # Those Who Leave
 2 | 
 3 | PC 4k intro, released at evoke 2017.
 4 | 
 5 | <img src="/Thumbnail.jpg?raw=true" alt="Thumbnail" width="100%"/>
 6 | 
 7 | ## Credits
 8 | 
 9 | [Koltes](https://github.com/KoltesDigital): direction, optimization, toolchain.
10 | 
11 | [Ponk](https://github.com/leon196): art, modeling.
12 | 
13 | [Unix](https://github.com/unixdal): music.
14 | 
15 | ## Demoscene is a big family
16 | 
17 | Framework derived from [wsmind](https://github.com/wsmind) and [halcy](https://github.com/halcy/), themselves took from iq...
18 | 
19 | Shader contains snippets from IQ, Mercury, LJ, Duke...
20 | 
21 | ## Build instructions
22 | 
23 | Requirements:
24 | 
25 | 1. Windows only.
26 | 2. [Visual Studio](https://www.visualstudio.com/) for the C++ compiler.
27 | 3. [NASM](http://www.nasm.us) for the ASM compiler.
28 | 4. [Crinkler](http://www.crinkler.net/) for the linker, unzipped somewhere and available in the PATH.
29 | 5. [Node.js](https://nodejs.org/) for the toolchain.
30 | 
31 | Open a *VS x86 tools prompt* and execute:
32 | 
33 | 	npm install
34 | 	npm run build
35 | 
36 | ## Development
37 | 
38 | Shaders are developed within [Synthclipse](http://synthclipse.sourceforge.net/).
39 | 
40 | In order to automatically build when a file changes, execute:
41 | 
42 | 	npm run watch
43 | 


--------------------------------------------------------------------------------
/src/time.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #ifdef CAPTURE_FRAMES
 4 | 
 5 | static int frameNumber;
 6 | static HANDLE frameFile;
 7 | static DWORD frameBytesWritten;
 8 | static char *frameBuffer;
 9 | 
10 | static char *frameFilename(int n)
11 | {
12 | 	static char *name = "frame00000.raw";
13 | 	char *ptr = name + 9;
14 | 
15 | 	while (n > 0)
16 | 	{
17 | 		*ptr-- = (n - (n / 10) * 10) + '0';
18 | 		n /= 10;
19 | 	}
20 | 
21 | 	return name;
22 | }
23 | 
24 | static void startTime()
25 | {
26 | 	frameNumber = 0;
27 | 	frameBuffer = (char *)HeapAlloc(GetProcessHeap(), 0, width * height * 3 /* RGB8 */);
28 | }
29 | 
30 | static float getTime()
31 | {
32 | 	return frameNumber / captureFPS;
33 | }
34 | 
35 | #define capture() \
36 | 	glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, frameBuffer); \
37 | 	frameFile = CreateFile(frameFilename(frameNumber), GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL); \
38 | 	if (frameFile) \
39 | 	{ \
40 | 		WriteFile(frameFile, frameBuffer, width * height * 3, &frameBytesWritten, NULL); \
41 | 		CloseHandle(frameFile); \
42 | 	} \
43 | 	frameNumber++; \
44 | 	if (getTime() >= captureDuration) \
45 | 		break
46 | 
47 | #else
48 | 
49 | static void startTime()
50 | {
51 | }
52 | 
53 | static float getTime()
54 | {
55 | 	waveOutGetPosition(waveOut, &mmTime, sizeof(MMTIME));
56 | 	return (float)mmTime.u.sample / (float)SAMPLE_RATE;
57 | }
58 | 
59 | static void capture()
60 | {
61 | }
62 | 
63 | #endif
64 | 


--------------------------------------------------------------------------------
/src/gl.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | // relevant glext.h fragment
 4 | #define APIENTRYP __stdcall *
 5 | typedef char GLchar;
 6 | #define GL_FRAGMENT_SHADER 0x8B30
 7 | typedef void(APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader);
 8 | typedef void(APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader);
 9 | typedef GLuint(APIENTRYP PFNGLCREATEPROGRAMPROC)(void);
10 | typedef GLuint(APIENTRYP PFNGLCREATESHADERPROC)(GLenum type);
11 | typedef void(APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program);
12 | typedef void(APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length);
13 | typedef void(APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program);
14 | typedef void(APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value);
15 | // end of glext.h fragment
16 | 
17 | #define GL_EXT_FUNCTION_COUNT 8
18 | 
19 | static const char *glExtFunctionNames[] = {
20 | 	"glAttachShader",
21 | 	"glCompileShader",
22 | 	"glCreateProgram",
23 | 	"glCreateShader",
24 | 	"glLinkProgram",
25 | 	"glShaderSource",
26 | 	"glUseProgram",
27 | 	"glUniform1fv",
28 | };
29 | 
30 | static void *glExtFunctions[GL_EXT_FUNCTION_COUNT];
31 | 
32 | #define glAttachShader ((PFNGLATTACHSHADERPROC)glExtFunctions[0])
33 | #define glCompileShader ((PFNGLCOMPILESHADERPROC)glExtFunctions[1])
34 | #define glCreateProgram ((PFNGLCREATEPROGRAMPROC)glExtFunctions[2])
35 | #define glCreateShader ((PFNGLCREATESHADERPROC)glExtFunctions[3])
36 | #define glLinkProgram ((PFNGLLINKPROGRAMPROC)glExtFunctions[4])
37 | #define glShaderSource ((PFNGLSHADERSOURCEPROC)glExtFunctions[5])
38 | #define glUseProgram ((PFNGLUSEPROGRAMPROC)glExtFunctions[6])
39 | #define glUniform1fv ((PFNGLUNIFORM1FVPROC)glExtFunctions[7])
40 | 


--------------------------------------------------------------------------------
/src/shots.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | struct Shot
  4 | {
  5 | 	float endBeat;
  6 | 	float startCameraPosition[3];
  7 | 	float startCameraAngles[3];
  8 | 	float endCameraPosition[3];
  9 | 	float endCameraAngles[3];
 10 | 	float startSeedPosition[3];
 11 | 	float endSeedPosition[3];
 12 | };
 13 | 
 14 | static Shot shots[] = {
 15 | 	{
 16 | 		24,
 17 | 		{ 0.f, 8.f, -16.f },
 18 | 		{ -.8f, 0.f, 0.f },
 19 | 		{ 0.f, 4.f, -12.f },
 20 | 		{ 0.3f, 0.f, 0.f },
 21 | 		{ 0.f, 0.f, -16.f },
 22 | 		{ 0.f, 0.f, -16.f },
 23 | 	},
 24 | 	{
 25 | 		32,
 26 | 		{ -3.5f, 1.8f, -3.3f },
 27 | 		{ 0.2f, -0.4f, 0.f },
 28 | 		{ -3.5f, 1.8f, -3.3f },
 29 | 		{ 0.2f, -1.f, 0.f },
 30 | 		{ 0.f, 0.f, -16.f },
 31 | 		{ 0.f, 0.f, -16.f },
 32 | 	},
 33 | 	{
 34 | 		44,
 35 | 		{ 0.5f, -0.7f, -8.f },
 36 | 		{ -0.2f, -0.2f, 0.f },
 37 | 		{ -0.2f, 1.f, -3.f },
 38 | 		{ 0.2f, 0.f, 0.f },
 39 | 		{ 7.f, .5f, 2.5f },
 40 | 		{ 0.f, 1.f, 0.f },
 41 | 	},
 42 | 	{
 43 | 		64,
 44 | 		{ 0.0f, 0.f, -2.f },
 45 | 		{ 0.f, -0.4f, .3f },
 46 | 		{ 0.0f, 3.f, -3.f },
 47 | 		{ 0.8f, 0.f, 0.f },
 48 | 		{ 0.f, 1.f, 0.f },
 49 | 		{ 0.f, -3.f, 0.f },
 50 | 	},
 51 | 	{
 52 | 		76,
 53 | 		{ -2.f, -.1f, -12.f },
 54 | 		{ -0.2f, -.2f, 0.5f },
 55 | 		{ 2.f, 1.f, -8.f },
 56 | 		{ 0.2f, 0.2f, 0.2f },
 57 | 	},
 58 | 	{
 59 | 		88,
 60 | 		{ 0.f, 1.f, -1.f },
 61 | 		{ 0.7f, 0.f, 0.f },
 62 | 		{ 0.f, 1.f, -2.f },
 63 | 		{ -.8f, 0.f, 0.f },
 64 | 	},
 65 | 	{
 66 | 		104,
 67 | 		{ 0.f, 7.f, -1.f },
 68 | 		{ 1.4f, 0.f, 0.f },
 69 | 		{ 0.f, 9.f, -1.f },
 70 | 		{ 1.4f, 0.f, 0.f },
 71 | 	},
 72 | 	{
 73 | 		120,
 74 | 		{ 0.f, 2.f, -1.f },
 75 | 		{ -1.4f, 0.f, 0.5f },
 76 | 		{ 0.f, 8.f, -1.f },
 77 | 		{ -1.4f, 0.f, -0.5f },
 78 | 	},
 79 | 	{
 80 | 		136,
 81 | 		{ 0.f, 0.f, 6.f },
 82 | 		{ 0.2f, 3.14f, 0.f },
 83 | 		{ 0.f, 0.f, 3.f },
 84 | 		{ -1.2f, 3.14f, 0.f },
 85 | 	},
 86 | 	{
 87 | 		160,
 88 | 		{ 0.f, 14.f, -1.5f },
 89 | 		{ 1.4f, 0.f, 0.f },
 90 | 		{ 0.f, 26.f, -.2f },
 91 | 		{ 1.5f, 0.f, 0.f },
 92 | 	},
 93 | 	{
 94 | 		184,
 95 | 		{ 0.f, -5.f, -15.f },
 96 | 		{ -0.5f, 0.f, -0.5f },
 97 | 		{ 0.f, 28.f, -5.f },
 98 | 		{ 1.f, 0.f, 0.3f },
 99 | 		{ 0.f, 5.f, 0.f },
100 | 		{ 0.f, 15.f, 0.f },
101 | 	},
102 | 	{
103 | 		212,
104 | 		{ 0.f, 22.f, -1.f },
105 | 		{ 0.5f, 0.f, 0.f },
106 | 		{ 0.f, 20.f, -8.f },
107 | 		{ -0.5f, 0.f, 0.f },
108 | 		{ 0.f, 20.f, 0.f },
109 | 		{ 0.f, 24.f, 0.f },
110 | 	},
111 | };
112 | 


--------------------------------------------------------------------------------
/shaders/shader.preset:
--------------------------------------------------------------------------------
 1 | /*!
 2 |  * <preset name="Default" fps="60" frameCount="7800" stepSize="0.2">
 3 |  *  BPM = <1.0|10.0|200.0> 100.0
 4 |  *  CamHeight = <1.0|5.0|50.0> 21.0
 5 |  *  CloudColor0 = <0.004, 0.004, 0.004> 0.6, 1.0, 1.0
 6 |  *  CloudColor1 = <0.004, 0.004, 0.004> 0.2, 0.2, 0.4
 7 |  *  Direction = <0.1, 0.1, 0.1> 0.46408966, -0.7117283, -0.5273175
 8 |  *  DissolutionEnd = <1.0|0.0|300.0> 196.0
 9 |  *  DissolutionStart = <1.0|0.0|300.0> 194.0
10 |  *  EndCameraAnglesX = <0.8|-8.0|8.0> 0.4
11 |  *  EndCameraAnglesY = <0.8|-8.0|8.0> 0.0
12 |  *  EndCameraAnglesZ = <0.8|-8.0|8.0> 0.0
13 |  *  EndCameraPositionX = <1.0|-10.0|10.0> -0.2
14 |  *  EndCameraPositionY = <1.0|-10.0|30.0> 2.0
15 |  *  EndCameraPositionZ = <1.0|-10.0|10.0> -3.0
16 |  *  EndSeedPositionX = <1.0|-10.0|10.0> -6.0
17 |  *  EndSeedPositionY = <1.0|-10.0|30.0> 1.0
18 |  *  EndSeedPositionZ = <1.0|-10.0|10.0> 1.0
19 |  *  EquiRectangular = false
20 |  *  Exposure = <0.5|0.0|16.0> 3.0
21 |  *  Eye = <1.0, 1.0, 1.0|-50.0, -50.0, -50.0|50.0, 50.0, 50.0> -4.7041225, 6.167966, 4.835952
22 |  *  FOV = <0.1|0.0|2.0> 0.4
23 |  *  FadeInEnd = <1.0|0.0|300.0> 8.0
24 |  *  FadeInStart = <1.0|0.0|300.0> 0.0
25 |  *  FadeOutEnd = <1.0|0.0|300.0> 212.0
26 |  *  FadeOutStart = <1.0|0.0|300.0> 204.0
27 |  *  FlowerColor0 = <0.004, 0.004, 0.004> 1.0, 0.5411765, 0.5411765
28 |  *  FlowerColor1 = <0.004, 0.004, 0.004> 1.0, 0.81960785, 0.8039216
29 |  *  FlowerEnd = <1.0|0.0|300.0> 160.0
30 |  *  FlowerStart = <1.0|0.0|300.0> 144.0
31 |  *  GroundBottomColor = <0.004, 0.004, 0.004> 0.3, 0.2, 0.1
32 |  *  GroundTopColor0 = <0.004, 0.004, 0.004> 0.0, 1.0, 1.0
33 |  *  GroundTopColor1 = <0.004, 0.004, 0.004> 0.0, 0.5019608, 1.0
34 |  *  Octaves = <0.5|0.0|10.0> 4.0
35 |  *  RootAmplitude = <0.25|0.0|5.0> 1.7
36 |  *  RootColor0 = <0.004, 0.004, 0.004> 1.0, 0.0, 0.1
37 |  *  RootColor1 = <0.004, 0.004, 0.004> 1.0, 0.6, 0.1
38 |  *  RootDamping = <0.25|0.0|1.5> 1.3
39 |  *  RootEnd = <1.0|0.0|300.0> 68.0
40 |  *  RootFadeDamping = <0.25|0.0|5.0> 0.6
41 |  *  RootFall = <0.5|0.0|10.0> 4.0
42 |  *  RootPulsation = <0.5|0.0|10.0> 2.6
43 |  *  RootStart = <1.0|0.0|300.0> 48.0
44 |  *  RootSubHelixStep = <0.5|0.0|10.0> 3.0
45 |  *  RootSubRadius = <0.015000001|0.0|0.3> 0.07
46 |  *  SeedColor = <0.004, 0.004, 0.004> 1.0, 1.0, 1.0
47 |  *  SkyColor0 = <0.004, 0.004, 0.004> 0.0, 0.0, 0.0
48 |  *  SkyColor1 = <0.004, 0.004, 0.004> 0.0, 0.019607844, 0.050980393
49 |  *  StarColor = <0.004, 0.004, 0.004> 0.1, 0.1, 0.1
50 |  *  StartCameraAnglesX = <0.8|-8.0|8.0> -0.2
51 |  *  StartCameraAnglesY = <0.8|-8.0|8.0> -0.2
52 |  *  StartCameraAnglesZ = <0.8|-8.0|8.0> 0.0
53 |  *  StartCameraPositionX = <1.0|-10.0|10.0> 0.5
54 |  *  StartCameraPositionY = <1.0|-10.0|30.0> -0.7
55 |  *  StartCameraPositionZ = <1.0|-10.0|10.0> -8.0
56 |  *  StartEndRatio = <0.05|0.0|1.0> *AX* \
57 |  *   AWYBTk8AAARzMAAAAAAAAAYvMD+AAAA=
58 |  *  StartSeedPositionX = <1.0|-10.0|10.0> -4.0
59 |  *  StartSeedPositionY = <1.0|-10.0|30.0> 1.0
60 |  *  StartSeedPositionZ = <1.0|-10.0|10.0> 9.0
61 |  *  StemColor0 = <0.004, 0.004, 0.004> 1.0, 0.0, 0.7
62 |  *  StemColor1 = <0.004, 0.004, 0.004> 1.0, 0.6, 0.0
63 |  *  StemEnd = <1.0|0.0|300.0> 160.0
64 |  *  StemGrowFactor = <1.0|0.0|300.0> 0.25
65 |  *  StemMaxHeight = <1.0|0.0|300.0> 20.0
66 |  *  StemRadius = <0.05|0.0|1.0> 0.15
67 |  *  StemStart = <1.0|0.0|300.0> 78.0
68 |  *  Steps = <1.0|5.0|50.0> 50.0
69 |  *  SynthclipseCamera = false
70 |  *  Up = <0.1, 0.1, 0.1> 0.13053678, 0.64376163, -0.75401
71 |  * </preset>
72 |  */


--------------------------------------------------------------------------------
/shaders/shader.glsl:
--------------------------------------------------------------------------------
 1 | 
 2 | uniform vec2 synth_Resolution;
 3 | uniform float synth_Time;
 4 | uniform mat4 synth_ViewMatrix;
 5 | 
 6 | //! <group name="Audio"/>
 7 | uniform float BPM; //! slider[10, 100, 200]
 8 | #define Beat (synth_Time*BPM/60.)
 9 | 
10 | //! <group name="Scene"/>
11 | uniform float CamHeight; //! slider[5, 21, 50]
12 | uniform float Octaves; //! slider[0, 4, 10]
13 | uniform vec3 GroundTopColor0; //! color[1, 1, 1]
14 | uniform vec3 GroundTopColor1; //! color[1, 1, 1]
15 | uniform vec3 GroundBottomColor; //! color[1, 1, 1]
16 | uniform vec3 SeedColor; //! color[1, 1, 1]
17 | uniform vec3 RootColor0; //! color[1, 1, 1]
18 | uniform vec3 RootColor1; //! color[1, 1, 1]
19 | uniform float RootFadeDamping; //! slider[0, .5, 5]
20 | uniform float RootAmplitude; //! slider[0, .5, 5]
21 | uniform float RootPulsation; //! slider[0, 5, 10]
22 | uniform float RootDamping; //! slider[0, .5, 50]
23 | uniform float RootSubRadius; //! slider[0, .05, .3]
24 | uniform float RootSubHelixStep; //! slider[0, 5, 10]
25 | uniform float RootFall; //! slider[0, 5, 10]
26 | uniform vec3 StemColor0; //! color[1, 1, 1]
27 | uniform vec3 StemColor1; //! color[1, 1, 1]
28 | uniform float StemRadius; //! slider[0, .5, 1]
29 | uniform float StemGrowFactor; //! slider[0, 20, 300]
30 | uniform float StemMaxHeight; //! slider[0, 20, 300]
31 | uniform vec3 FlowerColor0; //! color[1, 1, 1]
32 | uniform vec3 FlowerColor1; //! color[1, 1, 1]
33 | uniform float Exposure; //! slider[0, 5, 10]
34 | uniform vec3 CloudColor0; //! color[1, 1, 1]
35 | uniform vec3 CloudColor1; //! color[1, 1, 1]
36 | uniform vec3 SkyColor0; //! color[1, 1, 1]
37 | uniform vec3 SkyColor1; //! color[1, 1, 1]
38 | uniform vec3 StarColor; //! color[1, 1, 1]
39 | 
40 | //! <group name="Raymarching"/>
41 | uniform float Steps; //! slider[5, 10, 50]
42 | 
43 | //! <group name="Shot"/>
44 | uniform bool SynthclipseCamera; //! checkbox[false]
45 | uniform float StartEndRatio; //! slider[0, 0.5, 1]
46 | uniform float StartCameraPositionX; //! slider[-10, 0, 10]
47 | uniform float StartCameraPositionY; //! slider[-10, 0, 30]
48 | uniform float StartCameraPositionZ; //! slider[-10, 0, 10]
49 | uniform float StartCameraAnglesX; //! slider[-8, 0, 8]
50 | uniform float StartCameraAnglesY; //! slider[-8, 0, 8]
51 | uniform float StartCameraAnglesZ; //! slider[-8, 0, 8]
52 | uniform float EndCameraPositionX; //! slider[-10, 0, 10]
53 | uniform float EndCameraPositionY; //! slider[-10, 0, 30]
54 | uniform float EndCameraPositionZ; //! slider[-10, 0, 10]
55 | uniform float EndCameraAnglesX; //! slider[-8, 0, 8]
56 | uniform float EndCameraAnglesY; //! slider[-8, 0, 8]
57 | uniform float EndCameraAnglesZ; //! slider[-8, 0, 8]
58 | uniform float StartSeedPositionX; //! slider[-10, 0, 10]
59 | uniform float StartSeedPositionY; //! slider[-10, 0, 30]
60 | uniform float StartSeedPositionZ; //! slider[-10, 0, 10]
61 | uniform float EndSeedPositionX; //! slider[-10, 0, 10]
62 | uniform float EndSeedPositionY; //! slider[-10, 0, 30]
63 | uniform float EndSeedPositionZ; //! slider[-10, 0, 10]
64 | 
65 | //! <group name="Timing"/>
66 | uniform float FadeInStart; //! slider[0, 0.1, 300]
67 | uniform float FadeInEnd; //! slider[0, 1, 300]
68 | uniform float RootStart; //! slider[0, 5.1, 300]
69 | uniform float RootEnd; //! slider[0, 15, 300]
70 | uniform float StemStart; //! slider[0, 7.2, 300]
71 | uniform float StemEnd; //! slider[0, 87.2, 300]
72 | uniform float FlowerStart; //! slider[0, 70, 300]
73 | uniform float FlowerEnd; //! slider[0, 100, 300]
74 | uniform float DissolutionStart; //! slider[0, 102, 300]
75 | uniform float DissolutionEnd; //! slider[0, 118, 300]
76 | uniform float FadeOutStart; //! slider[0, 120, 300]
77 | uniform float FadeOutEnd; //! slider[0, 124, 300]
78 | 


--------------------------------------------------------------------------------
/src/intro.cpp:
--------------------------------------------------------------------------------
  1 | #define WIN32_LEAN_AND_MEAN
  2 | #define WIN32_EXTRA_LEAN
  3 | #include <windows.h>
  4 | 
  5 | #include <GL/gl.h>
  6 | #include <MMSystem.h>
  7 | #include <MMReg.h>
  8 | 
  9 | #define HALF_SCREEN
 10 | 
 11 | #include <audio/4klang.h>
 12 | #include <build/generated.hpp>
 13 | 
 14 | #include "audio.hpp"
 15 | #include "gl.hpp"
 16 | #include "shots.hpp"
 17 | #include "time.hpp"
 18 | #include "window.hpp"
 19 | 
 20 | void entry()
 21 | {
 22 | #ifndef FORCE_RESOLUTION
 23 | 	width = GetSystemMetrics(SM_CXSCREEN);
 24 | 	height = GetSystemMetrics(SM_CYSCREEN);
 25 | 
 26 | #ifdef HALF_SCREEN
 27 | 	width /= 4;
 28 | 	height /= 4;
 29 | #endif
 30 | #endif
 31 | 
 32 | 	auto hwnd = CreateWindow("static", NULL, WS_POPUP | WS_VISIBLE, 0, 0, width, height, NULL, NULL, NULL, 0);
 33 | 	auto hdc = GetDC(hwnd);
 34 | 	SetPixelFormat(hdc, ChoosePixelFormat(hdc, &pfd), &pfd);
 35 | 	wglMakeCurrent(hdc, wglCreateContext(hdc));
 36 | 	ShowCursor(FALSE);
 37 | 
 38 | 	for (auto i = 0; i < GL_EXT_FUNCTION_COUNT; ++i)
 39 | 		glExtFunctions[i] = wglGetProcAddress(glExtFunctionNames[i]);
 40 | 
 41 | 	GLint program = glCreateProgram();
 42 | 	GLint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
 43 | 	glShaderSource(fragmentShader, 1, &shaderSource, 0);
 44 | 	glCompileShader(fragmentShader);
 45 | 	glAttachShader(program, fragmentShader);
 46 | 	glLinkProgram(program);
 47 | 	glUseProgram(program);
 48 | 
 49 | 	CreateThread(0, 0, (LPTHREAD_START_ROUTINE)_4klang_render, soundBuffer, 0, 0);
 50 | 	waveOutOpen(&waveOut, WAVE_MAPPER, &waveFormat, NULL, 0, CALLBACK_NULL);
 51 | 	waveOutPrepareHeader(waveOut, &waveHDR, sizeof(waveHDR));
 52 | 	waveOutWrite(waveOut, &waveHDR, sizeof(waveHDR));
 53 | 
 54 | 	startTime();
 55 | 
 56 | 	float startBeat{};
 57 | 	Shot *currentShot = shots;
 58 | 
 59 | 	do
 60 | 	{
 61 | 		// avoid 'not responding' system messages
 62 | 		PeekMessage(NULL, NULL, 0, 0, PM_REMOVE);
 63 | 
 64 | 		float beat = (BPM / 60.f) * getTime();
 65 | 		//beat += 44;
 66 | 		//beat *= 16;
 67 | 
 68 | 		if (beat >= currentShot->endBeat)
 69 | 		{
 70 | 			startBeat = currentShot->endBeat;
 71 | 			++ currentShot;
 72 | 		}
 73 | 
 74 | 		uniformBeat = beat;
 75 | 		uniformEndCameraAnglesX = currentShot->endCameraAngles[0];
 76 | 		uniformEndCameraAnglesY = currentShot->endCameraAngles[1];
 77 | 		uniformEndCameraAnglesZ = currentShot->endCameraAngles[2];
 78 | 		uniformEndCameraPositionX = currentShot->endCameraPosition[0];
 79 | 		uniformEndCameraPositionY = currentShot->endCameraPosition[1];
 80 | 		uniformEndCameraPositionZ = currentShot->endCameraPosition[2];
 81 | 		uniformEndSeedPositionX = currentShot->endSeedPosition[0];
 82 | 		uniformEndSeedPositionY = currentShot->endSeedPosition[1];
 83 | 		uniformEndSeedPositionZ = currentShot->endSeedPosition[2];
 84 | 		uniformStartCameraAnglesX = currentShot->startCameraAngles[0];
 85 | 		uniformStartCameraAnglesY = currentShot->startCameraAngles[1];
 86 | 		uniformStartCameraAnglesZ = currentShot->startCameraAngles[2];
 87 | 		uniformStartCameraPositionX = currentShot->startCameraPosition[0];
 88 | 		uniformStartCameraPositionY = currentShot->startCameraPosition[1];
 89 | 		uniformStartCameraPositionZ = currentShot->startCameraPosition[2];
 90 | 		uniformStartSeedPositionX = currentShot->startSeedPosition[0];
 91 | 		uniformStartSeedPositionY = currentShot->startSeedPosition[1];
 92 | 		uniformStartSeedPositionZ = currentShot->startSeedPosition[2];
 93 | 		uniformStartEndRatio = (beat - startBeat) / (currentShot->endBeat - startBeat);
 94 | 
 95 | #ifndef FORCE_RESOLUTION
 96 | 		uniformResolutionHeight = (float)height;
 97 | 		uniformResolutionWidth = (float)width;
 98 | #endif
 99 | 
100 | 		// hack - assume that the uniforms u[] will always be linked to locations [0-n]
101 | 		// given that they are the only uniforms in the shader, it is likely to work on all drivers
102 | 		glUniform1fv(0, UNIFORM_COUNT, uniforms);
103 | 
104 | 		glRects(-1, -1, 1, 1);
105 | 
106 | 		capture();
107 | 
108 | 		wglSwapLayerBuffers(hdc, WGL_SWAP_MAIN_PLANE);
109 | 	} while (
110 | 		// mmTime.u.sample < MAX_PATTERNS * SAMPLES_PER_TICK * PATTERN_SIZE &&
111 | 		!GetAsyncKeyState(VK_ESCAPE));
112 | 
113 | 	ExitProcess(0);
114 | }
115 | 


--------------------------------------------------------------------------------
/scripts/build.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | const { audioDirectory, buildDirectory, distDirectory, shadersDirectory, srcDirectory } = require('./directories');
  4 | const { readFile, readFileSync, stat, writeFile } = require('fs');
  5 | const { safeLoad } = require('js-yaml');
  6 | const makeDir = require('make-dir');
  7 | const { Notification } = require('node-notifier');
  8 | const { dirname, join, resolve } = require('path');
  9 | const rimrafPromise = require('rimraf-promise');
 10 | const spawnPromise = require('./spawn-promise');
 11 | 
 12 | const config = safeLoad(readFileSync('config.yml'));
 13 | 
 14 | function dir(path) {
 15 | 	return rimrafPromise(join(path, '*'))
 16 | 		.then(() => makeDir(path));
 17 | }
 18 | 
 19 | console.log('Creating directories.');
 20 | Promise.all([
 21 | 	dir(buildDirectory),
 22 | 	dir(join(distDirectory, dirname(config.distFile)))
 23 | ])
 24 | .then(() => {
 25 | 	console.log('Preparing shader.');
 26 | 	return new Promise((resolve, reject) => {
 27 | 		return readFile(join(shadersDirectory, config.shaderFile), (err, shaderContents) => {
 28 | 			if (err)
 29 | 				return reject(err);
 30 | 			else
 31 | 				return resolve(shaderContents.toString());
 32 | 		});
 33 | 	})
 34 | 		.then(shaderContents => {
 35 | 			return new Promise((resolve, reject) => {
 36 | 				const constantsMap = {};
 37 | 				const presetMatch = shaderContents.match(/\/\/!\s+<preset\s+file="(.+)"\s*\/>/);
 38 | 				if (!presetMatch) {
 39 | 					console.warn('Shader does not have any preset file.');
 40 | 					return resolve({ shaderContents, constantsMap });
 41 | 				}
 42 | 
 43 | 				return readFile(join(shadersDirectory, presetMatch[1]), (err, presetContents) => {
 44 | 					if (err)
 45 | 						return reject(err);
 46 | 
 47 | 					presetContents = presetContents.toString();
 48 | 
 49 | 					const presetRegExp = /\/\*\!([\s\S]*?<preset\s+name="(\w+?)"[\s\S]*?)\*\//g;
 50 | 					let presetMatch;
 51 | 					let presetFound = false;
 52 | 					while ((presetMatch = presetRegExp.exec(presetContents)) !== null) {
 53 | 						if (presetMatch[2] === config.constantsPreset) {
 54 | 							presetFound = true;
 55 | 
 56 | 							const constantRegExp = /(\w+) = <.*?> (.*)/g;
 57 | 							let constantMatch;
 58 | 							while ((constantMatch = constantRegExp.exec(presetMatch[1])) !== null) {
 59 | 								const name = constantMatch[1];
 60 | 								if (config.uniforms.indexOf(name) !== -1)
 61 | 									continue;
 62 | 
 63 | 								const components = constantMatch[2].split(', ');
 64 | 								switch (components.length) {
 65 | 								case 1:
 66 | 									constantsMap[name] = {
 67 | 										type: 'float',
 68 | 										value: components[0],
 69 | 									};
 70 | 									break;
 71 | 
 72 | 								case 2:
 73 | 									constantsMap[name] = {
 74 | 										type: 'vec2',
 75 | 										value: 'vec2(' + components.join(', ') + ')',
 76 | 									};
 77 | 									break;
 78 | 
 79 | 								case 3:
 80 | 									constantsMap[name] = {
 81 | 										type: 'vec3',
 82 | 										value: 'vec3(' + components.join(', ') + ')',
 83 | 									};
 84 | 									break;
 85 | 
 86 | 								case 4:
 87 | 									constantsMap[name] = {
 88 | 										type: 'vec4',
 89 | 										value: 'vec4(' + components.join(', ') + ')',
 90 | 									};
 91 | 									break;
 92 | 								}
 93 | 							}
 94 | 						}
 95 | 					}
 96 | 
 97 | 					if (!presetFound)
 98 | 						console.warn('Preset was not found.');
 99 | 
100 | 					return resolve({ shaderContents, constantsMap });
101 | 				});
102 | 			});
103 | 		})
104 | 		.then(({ shaderContents, constantsMap }) => {
105 | 			return new Promise((resolve, reject) => {
106 | 				const beginMatch = shaderContents.match(/^\/\/\s*?begin([\s\S]+)/m);
107 | 				if (!beginMatch)
108 | 					return reject(new Error('Shader does not contain the magic line "// begin".'));
109 | 
110 | 				let shader = beginMatch[1]
111 | 					.replace(/#ifdef\s+SYNTHCLIPSE_ONLY[\s\S]*?(?:#else([\s\S]*?))?#endif/g, '$1')
112 | 					.replace(/#ifndef\s+SYNTHCLIPSE_ONLY([\s\S]*?)(?:#else[\s\S]*?)?#endif/g, '$1')
113 | 					.replace(/\bconst\b/g, '');
114 | 
115 | 				function addGlobal(type, value) {
116 | 					if (!config.globals[type])
117 | 						config.globals[type] = [];
118 | 					config.globals[type].push(value);
119 | 				}
120 | 
121 | 				if (config.capture) {
122 | 					addGlobal('vec2', 'synth_Resolution = vec2(' + config.capture.width + ', ' + config.capture.height + ')');
123 | 				} else if (config.forceResolution) {
124 | 					addGlobal('vec2', 'synth_Resolution = vec2(' + config.forceResolution.width + ', ' + config.forceResolution.height + ')');
125 | 				} else {
126 | 					const uniformWidthName = 'resolutionWidth',
127 | 						uniformHeightName = 'resolutionHeight';
128 | 					addGlobal('vec2', 'synth_Resolution = vec2(' + uniformWidthName + ', ' + uniformHeightName + ')');
129 | 					config.uniforms.push(uniformWidthName, uniformHeightName);
130 | 				}
131 | 
132 | 				Object.keys(constantsMap).forEach(constantName => {
133 | 					const constantEntry = constantsMap[constantName];
134 | 
135 | 					const re = new RegExp('\\b' + constantName + '\\b', 'g');
136 | 					let occurences = 0;
137 | 					while (re.exec(shader) !== null) {
138 | 						++occurences;
139 | 					}
140 | 
141 | 					if (occurences > 1) {
142 | 						addGlobal(constantEntry.type, constantName + ' = ' + constantEntry.value);
143 | 					} else if (occurences === 1) {
144 | 						shader = shader.replace(re, constantEntry.value);
145 | 					}
146 | 				});
147 | 
148 | 				const shaderLines = shader.split('\n');
149 | 
150 | 				let newShader = [
151 | 					'//! FRAGMENT',
152 | 					'uniform float _[' + config.uniforms.length + '];',
153 | 				]
154 | 					.concat(Object.keys(config.globals).map(type => {
155 | 						return type + ' ' + config.globals[type].join(', ') + ';';
156 | 					}))
157 | 					.concat(shaderLines)
158 | 					.join('\n');
159 | 
160 | 				config.uniforms.forEach((name, index) => {
161 | 					const re = new RegExp('\\b' + name + '\\b', 'g');
162 | 					newShader = newShader.replace(re, '_[' + index + ']');
163 | 				});
164 | 
165 | 				return writeFile(join(buildDirectory, 'shader.glsl'), newShader, (err) => {
166 | 					if (err)
167 | 						return reject(err);
168 | 					else
169 | 						return resolve();
170 | 				});
171 | 			});
172 | 		});
173 | })
174 | .then(() => {
175 | 	console.log('Minifying shader.');
176 | 	return spawnPromise('node', [
177 | 		join('node_modules', 'glsl-unit', 'bin', 'template_glsl_compiler.js'),
178 | 		'--input=' + join(buildDirectory, 'shader.glsl'),
179 | 		'--variable_renaming=INTERNAL',
180 | 		'--output=' + join(buildDirectory, 'shader.min.glsl'),
181 | 	]);
182 | })
183 | .then(() => {
184 | 	console.log('Generating header.');
185 | 	return new Promise((resolve, reject) => {
186 | 		return readFile(join(buildDirectory, 'shader.min.glsl'), (err, contents) => {
187 | 			if (err)
188 | 				return reject(err);
189 | 
190 | 			const lines = contents.toString().split('\n');
191 | 			const shader = lines[lines.length - 1];
192 | 
193 | 			const headerContents = [
194 | 				'static const char *shaderSource = "' + shader.replace(/\r/g, '') + '";',
195 | 				'#define UNIFORM_COUNT ' + config.uniforms.length,
196 | 				'static float uniforms[UNIFORM_COUNT];'
197 | 			];
198 | 
199 | 			config.uniforms.forEach((name, index) => {
200 | 				name = name
201 | 				.replace(/^\w|\b\w/g, letter => letter.toUpperCase())
202 | 				.replace(/_+/g, '');
203 | 				headerContents.push('#define uniform' + name + ' uniforms[' + index + ']');
204 | 			});
205 | 
206 | 			if (config.capture) {
207 | 				headerContents.push(
208 | 					'#define FORCE_RESOLUTION',
209 | 					'#define CAPTURE_FRAMES',
210 | 					'static const constexpr int width = ' + config.capture.width + ';',
211 | 					'static const constexpr int height = ' + config.capture.height + ';',
212 | 					'static const constexpr float captureFPS = ' + config.capture.fps + ';',
213 | 					'static const constexpr float captureDuration = ' + config.capture.duration + ';'
214 | 				);
215 | 			} else if (config.forceResolution) {
216 | 				headerContents.push(
217 | 					'#define FORCE_RESOLUTION',
218 | 					'static const constexpr int width = ' + config.forceResolution.width + ';',
219 | 					'static const constexpr int height = ' + config.forceResolution.height + ';'
220 | 				);
221 | 			} else {
222 | 				headerContents.push(
223 | 					'static int width, height;'
224 | 				);
225 | 			}
226 | 
227 | 			return writeFile(join(buildDirectory, 'generated.hpp'), headerContents.join('\n'), (err) => {
228 | 				if (err)
229 | 					return reject(err);
230 | 				else
231 | 					return resolve();
232 | 			});
233 | 		});
234 | 	});
235 | })
236 | .then(() => {
237 | 	console.log('Compiling intro.cpp.');
238 | 	return spawnPromise('cl', [
239 | 		'/O1',
240 | 		'/Oi',
241 | 		'/Oy',
242 | 		'/GR-',
243 | 		'/GS-',
244 | 		'/fp:fast',
245 | 		'/QIfist',
246 | 		'/arch:IA32',
247 | 		'/I.',
248 | 		'/FA',
249 | 		'/Fa' + join(buildDirectory, 'intro.asm'),
250 | 		'/c',
251 | 		'/Fo' + join(buildDirectory, 'intro.obj'),
252 | 		join(srcDirectory, 'intro.cpp'),
253 | 	]);
254 | })
255 | .then(() => {
256 | 	console.log('Compiling audio.inc.');
257 | 	return spawnPromise('nasm', [
258 | 		'-f',
259 | 		'win32',
260 | 		'-o',
261 | 		resolve(buildDirectory, '4klang.obj'),
262 | 		'4klang.asm',
263 | 	], {
264 | 		cwd: audioDirectory,
265 | 	});
266 | })
267 | .then(() => {
268 | 	console.log('Linking demo.');
269 | 	return spawnPromise('crinkler', [
270 | 		'/ENTRY:entry',
271 | 		'/PRIORITY:NORMAL',
272 | 		'/COMPMODE:FAST',
273 | 		'/RANGE:opengl32',
274 | 		// '/TRUNCATEFLOATS:16',
275 | 		'/UNSAFEIMPORT',
276 | 		'/REPORT:' + join(buildDirectory, 'stats.html'),
277 | 		'/OUT:' + join(distDirectory, config.distFile),
278 | 		join(buildDirectory, 'intro.obj'),
279 | 		join(buildDirectory, '4klang.obj'),
280 | 		'winmm.lib',
281 | 		'gdi32.lib',
282 | 		'opengl32.lib',
283 | 		'kernel32.lib',
284 | 		'user32.lib',
285 | 	]);
286 | })
287 | .then(() => {
288 | 	return new Promise((resolve, reject) => {
289 | 		return stat(join(distDirectory, config.distFile), (err, stats) => {
290 | 			if (err)
291 | 				return reject(err);
292 | 			else
293 | 				return resolve(stats.size);
294 | 		});
295 | 	});
296 | })
297 | .then((size) => {
298 | 	const notifier = new Notification({
299 | 		withFallback: true,
300 | 	});
301 | 
302 | 	notifier.notify({
303 | 		title: 'Final size',
304 | 		message: size + ' bytes',
305 | 		wait: true,
306 | 	});
307 | 
308 | 	notifier.on('click', () => {
309 | 		spawnPromise(join(distDirectory, config.distFile))
310 | 		.catch(console.error);
311 | 	});
312 | })
313 | .catch(console.error);
314 | 


--------------------------------------------------------------------------------
/shaders/shader.stoy:
--------------------------------------------------------------------------------
  1 | #include <Camera>
  2 | #include "shader.glsl"
  3 | 
  4 | const float TAU = 6.283;
  5 | 
  6 | float currentHeight,
  7 | 	hash,
  8 | 	stepIndex;
  9 | 
 10 | // begin
 11 | 
 12 | struct Z // Material
 13 | {
 14 | 	float d, // distance
 15 | 		m; // min distance
 16 | 	vec3 c; // color
 17 | };
 18 | 
 19 | vec3 hsv(float h, float s) {
 20 | 	vec3 k=vec3(3.,2.,1.)/3.,
 21 | 		p=abs(fract(h+k)*6.-3.);
 22 | 	return mix(k.xxx,clamp(p-k.xxx,0.,1.), s);
 23 | }
 24 | 
 25 | // timing functions
 26 | float sequence (float start, float end) {
 27 | 	return clamp((Beat-start)/(end-start), 0., 1.);
 28 | }
 29 | 
 30 | // transformation functions
 31 | mat2 rot (float a) {
 32 | 	float c=cos(a), s=sin(a);
 33 | 	return mat2(c,-s,s,c);
 34 | }
 35 | 
 36 | // noise functions
 37 | 
 38 | float hash1( float n ) {
 39 | 	return fract(sin(n)*43758.5453);
 40 | }
 41 | 
 42 | float hash2(vec2 co) {
 43 | 	return fract(sin(dot(co*0.123,vec2(12.9898,78.233))) * 43758.5453);
 44 | }
 45 | 
 46 | float hash3(vec3 p) {
 47 | 	p  = fract( p*0.3183099+.1 );
 48 | 	p *= 17.0;
 49 | 	return fract( p.x*p.y*p.z*(p.x+p.y+p.z) );
 50 | }
 51 | 
 52 | float noise(vec3 x) {
 53 | 	vec3 p = floor(x);
 54 | 	vec3 f = fract(x);
 55 | 	f = f*f*(3.0-2.0*f);
 56 | 	vec2 oi = vec2(0,1);
 57 | 	return mix(mix(mix( hash3(p),
 58 | 						hash3(p+oi.yxx),f.x),
 59 | 				mix( hash3(p+oi.xyx),
 60 | 						hash3(p+oi.yyx),f.x),f.y),
 61 | 			mix(mix( hash3(p+oi.xxy),
 62 | 						hash3(p+oi.yxy),f.x),
 63 | 				mix( hash3(p+oi.xyy),
 64 | 						hash3(p+oi.yyy),f.x),f.y),f.z);
 65 | }
 66 | 
 67 | float fbm (vec3 p, float s) {
 68 | 	float value = 0.0;
 69 | 	float amplitude = 1.;
 70 | 	for (int i = 0; i < Octaves; ++i) {
 71 | 		value += amplitude * noise(p);
 72 | 		p *= 2.;
 73 | 		p.yx *= rot(Beat*s*.5);
 74 | 		p.yz *= rot(Beat*s*.3);
 75 | 		p.xz *= rot(Beat*s*.6);
 76 | 		amplitude *= .5;
 77 | 	}
 78 | 	return value;
 79 | }
 80 | 
 81 | void amod(inout vec2 p, float count) {
 82 | 	float index = floor(mod(atan(p.y,p.x) / TAU * count + .5, count));
 83 | 	hash = hash1(index);
 84 | 	p *= rot(- index / count * TAU);
 85 | }
 86 | 
 87 | // volume distance sdf functions
 88 | float sdCone(vec3 p, vec2 c) {
 89 | 	return dot(c, vec2(length(p.xy), p.z));
 90 | }
 91 | float sdSphere (vec3 p, float r) {
 92 | 	return length(p)-r;
 93 | }
 94 | float sdCylinder (vec3 p, float r, float h) {
 95 | 	return max(abs(p.y)-h, length(p.xz)-r);
 96 | }
 97 | float sdCylinderCapped (vec3 p, float r, float hmin, float hmax) {
 98 | 	return max(max(-p.y+hmin, p.y-hmax), length(p.xz)-r);
 99 | }
100 | float sdCylinderBox (vec3 p, float r, float h) {
101 | 	vec2 d = abs(p.xz) - r;
102 | 	return max(abs(p.y)-h, min(max(d.x,d.y),0.0) + length(max(d,0.0))); }
103 | float sdPlane (float p, float r) {
104 | 	return abs(p)-r;
105 | }
106 | float sdBox (vec3 p, vec3 r) {
107 | 	return length(max(abs(p)-r,0.));
108 | }
109 | float sdIso (vec3 p, float r) {
110 | 	return dot(p, normalize(sign(p)))-r;
111 | }
112 | float sdTorus( vec3 p, vec2 s ) {
113 | 	vec2 q = vec2(length(p.xz)-s.x,p.y);
114 | 	return length(q)-s.y;
115 | }
116 | 
117 | // volume operation sdf functions
118 | 
119 | Z smin (Z a, Z b, float r) {
120 | 	float h = clamp(.5+.5*(b.d-a.d)/r,0.,1.);
121 | 	return Z(
122 | 		mix(b.d,a.d,h)-r*h*(1.-h),
123 | 		mix(b.m,a.m,h),
124 | 		mix(b.c,a.c,h)
125 | 	);
126 | }
127 | Z smax (Z a, Z b, float r) {
128 | 	float h = clamp(.5+.5*(b.d-a.d)/r,0.,1.);
129 | 	return Z(
130 | 		mix(a.d,b.d,h)+r*h*(1.-h),
131 | 		mix(a.m,b.m,h),
132 | 		mix(a.c,b.c,h)
133 | 	);
134 | }
135 | // displacement animation
136 | 
137 | vec3 stemDisplacement (vec3 p) {
138 | 	return vec3(cos(p.y),0.,sin(p.y)) * .5 * max(sin(TAU/2.*p.y/StemMaxHeight), 0.);
139 | }
140 | 
141 | Z sdGround (vec3 p) {
142 | 	float radius = 5.;
143 | 	float rootDown = .5 * pow(length(p.xz)/radius, 2.);
144 | 	float noisy = fbm(p*2., 0.);
145 | 	return smax(
146 | 		Z(sdSphere(p, radius - noisy*.2), .001, GroundBottomColor),
147 | 		Z(p.y + rootDown * (1. + noisy), .001, mix(GroundTopColor0, GroundTopColor1, stepIndex/Steps)),
148 | 		.02);
149 | }
150 | 
151 | Z sdSeed (vec3 p) {
152 | 	p += stemDisplacement(p);
153 | 	p.x -= mix(StartSeedPositionX, EndSeedPositionX, StartEndRatio);
154 | 	p.y -= max(mix(StartSeedPositionY, EndSeedPositionY, StartEndRatio), 0.);
155 | 	p.z -= mix(StartSeedPositionZ, EndSeedPositionZ, StartEndRatio);
156 | 
157 | 	p.z += sin(p.x*25.+sin(p.z*20.))*sin(p.y*10.)*.02;
158 | 	p.xy *= rot(Beat);
159 | 	p.xz *= rot(Beat);
160 | 	p.xy /= .6;
161 | 	float radius = .5;
162 | 	vec3 q = p;
163 | 	q.xy *= rot(Beat);
164 | 	q.yz *= rot(Beat);
165 | 	return Z(mix(sdIso(p, radius), sdSphere(p, radius), .6), .001, hsv(noise(q + Beat / 4.) + stepIndex/Steps, 1.));
166 | }
167 | 
168 | 
169 | Z sdRoots (vec3 p) {
170 | 	float count = 12.;
171 | 	float subCount = 3.;
172 | 
173 | 	amod(p.xz, count);
174 | 	float range = 3.;
175 | 	float d = length(p.xz);
176 | 	float len = 6. * sequence(RootStart+range*hash, RootEnd+range*hash);
177 | 	float fade = 1. - min(1., exp(RootFadeDamping * (d - len)));
178 | 	float rootDown = .8 * pow(min(d/5., 1.), 2.);
179 | 	float radius = (.1 + 0.02*sin(TAU * (Beat*.5 + d*.5 + hash))) * fade;
180 | 	p.xz *= rot(sin((3.+4.*hash)*(d+hash))*.1);
181 | 	p.y += RootAmplitude * cos(d * RootPulsation + hash) * clamp(exp(RootDamping * -d), 0., 1.)
182 | 			+ rootDown + smoothstep(4.5, 8., d) * RootFall;
183 | 
184 | 	//p.x -= len;
185 | 	p.yz *= rot(p.y * RootSubHelixStep);
186 | 	amod(p.yz, subCount);
187 | 	p.y -= RootSubRadius;
188 | 	return Z(sdCylinderCapped(p.yxz, radius, 0., len), .001, mix(RootColor0, RootColor1, stepIndex/Steps));
189 | }
190 | 
191 | Z sdMainStem (vec3 p) {
192 | 	vec3 color = mix(StemColor0, StemColor1, stepIndex/Steps);
193 | 	p += stemDisplacement(p);
194 | 	p.xz *= rot(Beat-p.y*2.);
195 | 	float radius = mix(-1.,StemRadius, sequence(StemStart,StemStart+0.01));
196 | 	radius *= .4+.5*(1.-sin(TAU/4.*(1.-clamp(p.y/currentHeight,0.,1.))));
197 | 	Z stem = Z(max(sdCylinderBox(p, radius, currentHeight), -p.y), .001, color);
198 | 	p.y -= currentHeight;
199 | 	float fadeSeed = mix(-1.,1.,sequence(StemStart+1.,StemStart+2.));
200 | 	Z top = Z(sdIso(p*.5,.1*fadeSeed), .001, color);
201 | 	return smin(stem, top, .1);
202 | }
203 | 
204 | float sdLeaf (vec3 p, float radius, float ratio) {
205 | 	p.y += p.x*(p.x/radius-3.)*.2;
206 | 	p.xy *= rot(.1 * sin(Beat * TAU / 4.));
207 | 
208 | 	float stem = max(sdCylinder(p.yxz, .1 * ratio * radius - .05 * p.x, 2.*radius), -p.x);
209 | 
210 | 	p.y -= sin(abs(2.*p.z/radius))*radius*.2;
211 | 	p.x += ( sin(abs(p.z/radius))*.5 - ratio * 2.) * radius;
212 | 
213 | 	return min(sdCylinder(p, ratio*radius, .05 * radius), stem);
214 | }
215 | 
216 | Z sdLeafs(vec3 p) {
217 | 	float LeafInterval = 8. * StemGrowFactor;
218 | 
219 | 	vec3 pOrig = p;
220 | 
221 | 	float radius = 1.5,
222 | 		ratio = 1. - min(1., exp(-.2 * (Beat - StemStart - 8. * 9.)));
223 | 
224 | 	p += stemDisplacement(p);
225 | 
226 | 	p.y -= 9. * LeafInterval;
227 | 	amod(p.xz, 4.);
228 | 	float shape = sdLeaf(p, radius, ratio);
229 | 
230 | 	for (float index = 1.; index < 9.; ++index) {
231 | 		p = pOrig + stemDisplacement(pOrig);
232 | 
233 | 		p.y -= index * LeafInterval;
234 | 
235 | 		radius = .5 + .05 * index;
236 | 		ratio = 1. - min(2., exp(-.2 * (Beat - StemStart - 8. * index)));
237 | 
238 | 		p.xz *= rot(3. - index * LeafInterval);
239 | 		shape = min(shape, sdLeaf(p, radius, ratio));
240 | 	}
241 | 
242 | 	return Z(max(shape, -pOrig.y), .001, mix(StemColor0, StemColor1, stepIndex/Steps));
243 | }
244 | 
245 | Z sdFlower (vec3 p0) {
246 | 	float bloom = mix(-1.,1., sin(sequence(FlowerStart, FlowerEnd)*TAU/4.));
247 | 
248 | 	//p0 += normalize(p0)*hash2(p0.xz)*sequence(EndStart-.9, EndEnd)*30.;
249 | 	float noise2 = fbm(p0*2., .0);
250 | 	//p0.y += 3. * noise2 * sequence(FinalEnd, EndEnd-1.)*(length(p0.xz)+1.);
251 | 	p0.y -= currentHeight - .5;
252 | 	vec3 p = p0;
253 | 	p.xz *= rot(sin(p.y*5.+Beat)*.5);
254 | 	amod(p.xz, 8.);
255 | 	float height = 2.*bloom;
256 | 	p.x -= .2+.1*sin((p.y-StemMaxHeight-Beat/4.)*TAU);
257 | 	//p.x -= .8*(sin(-p.y)*.5+.5);
258 | 	//p.y += -camHeight+1.-height;
259 | 	Z m = Z(sdCylinderCapped(p, .02*bloom, 0.5, height), .001, hsv(hash + Beat / 16., .6));
260 | 	p.y -= height;
261 | 	m = smin(m, Z(sdSphere(p, .1*bloom), .001, vec3(1)), .1);
262 | 
263 | 	p = p0;
264 | 	float count = 3.;
265 | 	float repeat = 5.;
266 | 	for (float i = 0.; i < count; ++i) {
267 | 		p = p0;
268 | 		//p.y += -camHeight+1.;
269 | 		p.y -= i*.15;
270 | 		p.xz *= rot((Beat / 16. + i/count) * TAU);
271 | 		amod(p.xz, repeat);
272 | 		p.z *= 2.;
273 | 		p.xy *= rot(-TAU/6. +p.x*.2+.1*sin((Beat + i) * TAU / 4.));
274 | 		p.x -= 1.3*bloom;
275 | 		m = smin(m,
276 | 			Z(sdCylinder(p, bloom, .01), .001,
277 | 				mix(vec3(1), hsv(hash - hash1(i) + Beat / 16., 1.), stepIndex/Steps)), 0.2);
278 | 	}
279 | 	return m;
280 | }
281 | 
282 | Z sdCloud (vec3 p) {
283 | 	p.y -= 40.-20.*sin(TAU/8.*clamp(length(p.xz)/200.,0.,1.));
284 | 	float shape = abs(p.y+5.*fbm(p*.2, .05))-5.*(noise(p*.1 + (Beat - p.x*.05) * .5)-.4);
285 | 	//shape = sdSphere(p, 1.+fbm(p, .1));
286 | 	shape = mix(1.,shape, clamp(length(p.xz),0.,1.));
287 | 	return Z(shape, 1., mix(CloudColor0, CloudColor1, stepIndex/Steps));
288 | }
289 | 
290 | Z map (vec3 p) {
291 | 	Z scene = sdCloud(p);
292 | 
293 | 	p.xz *= rot(Beat * .05);
294 | 	currentHeight = min(StemMaxHeight, StemGrowFactor * (Beat - StemStart));
295 | 
296 | 	scene = smin(scene, sdSeed(p), .1);
297 | 
298 | 	p.y += (fbm(p.xzz*4., .6)-.5+Beat-DissolutionStart)*sequence(DissolutionStart, DissolutionEnd);
299 | 
300 | 	scene = smin(scene, sdGround(p), .1);
301 | 	scene = smin(scene, sdRoots(p), .1);
302 | 	scene = smin(scene, sdMainStem(p), .1);
303 | 	scene = smin(scene, sdLeafs(p), .1);
304 | 	scene = smin(scene, sdFlower(p), .1);
305 | 	return scene;
306 | }
307 | 
308 | void main() {
309 | 	vec2 uv = gl_FragCoord.xy/synth_Resolution,
310 | 			v = uv * (1. - uv);
311 | 
312 |     uv -= .5;
313 |     uv.x *= synth_Resolution.x / synth_Resolution.y;
314 | 
315 | 	vec3 ray = normalize(vec3(uv,1)),
316 | 	pos = mix(
317 | 		vec3(StartCameraPositionX, StartCameraPositionY, StartCameraPositionZ),
318 | 		vec3(EndCameraPositionX, EndCameraPositionY, EndCameraPositionZ),
319 | 		StartEndRatio
320 | 	),
321 | 	color = vec3(0.);
322 | 	ray.xy *= rot(mix(StartCameraAnglesZ, EndCameraAnglesZ, StartEndRatio));
323 | 	ray.yz *= rot(mix(StartCameraAnglesX, EndCameraAnglesX, StartEndRatio));
324 | 	ray.xz *= rot(mix(StartCameraAnglesY, EndCameraAnglesY, StartEndRatio));
325 | 
326 | #ifdef SYNTHCLIPSE_ONLY
327 | 	if (SynthclipseCamera) {
328 | 		getCamera(pos, ray);
329 | 	}
330 | #endif
331 | 
332 | 	vec2 seed = uv + fract(Beat);
333 | 	for (stepIndex = 0.; stepIndex < Steps; ++stepIndex) {
334 | 		Z m = map(pos);
335 | 		if (abs(m.d) < m.m)
336 | 			color += m.c;
337 | 		pos += ray * max(m.m, abs(m.d)*(.8+.2*hash2(seed*stepIndex)));
338 | 	}
339 | 	color /= Steps;
340 | 
341 | 	ray.xy *= rot(Beat*.01);
342 | 	ray.xz *= rot(.5);
343 | 	gl_FragColor = vec4(
344 | 		sqrt(mix(
345 | 			mix(
346 | 				mix(SkyColor0, SkyColor1, noise(ray*3.)*noise(ray*.2))
347 | 			, StarColor, smoothstep(.94, 1., noise(ray*3e2))),
348 | 			color, step(1e-5, color)
349 | 		))
350 | 		 * Exposure
351 | 		 * sequence(FadeInStart, FadeInEnd)
352 | 	 	 * sequence(FadeOutEnd, FadeOutStart)
353 | 		 * pow(v.x * v.y * 15.0, 0.25)
354 | 	, 1.);
355 | }
356 | 
357 | //! <preset file="shader.preset" />
358 | 


--------------------------------------------------------------------------------
/audio/4klang.inc:
--------------------------------------------------------------------------------
  1 | %macro export_func 1
  2 |    global _%1
  3 |    _%1:
  4 | %endmacro
  5 | %define USE_SECTIONS
  6 | %define SAMPLE_RATE	44100
  7 | %define MAX_INSTRUMENTS	5
  8 | %define MAX_VOICES 2
  9 | %define HLD 1
 10 | %define BPM 100.000000
 11 | %define MAX_PATTERNS 53
 12 | %define PATTERN_SIZE_SHIFT 4
 13 | %define PATTERN_SIZE (1 << PATTERN_SIZE_SHIFT)
 14 | %define	MAX_TICKS (MAX_PATTERNS*PATTERN_SIZE)
 15 | %define	SAMPLES_PER_TICK 6615
 16 | %define DEF_LFO_NORMALIZE 0.0000377929
 17 | %define	MAX_SAMPLES	(SAMPLES_PER_TICK*MAX_TICKS)
 18 | ;%define 	GO4K_USE_16BIT_OUTPUT
 19 | ;%define 	GO4K_USE_GROOVE_PATTERN
 20 | ;%define 	GO4K_USE_ENVELOPE_RECORDINGS
 21 | ;%define 	GO4K_USE_NOTE_RECORDINGS
 22 | %define 	GO4K_CLIP_OUTPUT
 23 | %define 	GO4K_USE_DST
 24 | %define 	GO4K_USE_DLL
 25 | %define 	GO4K_USE_GLOBAL_DLL
 26 | %define 	GO4K_USE_FSTG
 27 | %define 	GO4K_USE_ENV_CHECK
 28 | %define 	GO4K_USE_ENV_MOD_GM
 29 | %define 	GO4K_USE_VCO_CHECK
 30 | %define 	GO4K_USE_VCO_PHASE_OFFSET
 31 | %define 	GO4K_USE_VCO_SHAPE
 32 | %define 	GO4K_USE_VCO_MOD_TM
 33 | %define 	GO4K_USE_VCO_MOD_DM
 34 | %define 	GO4K_USE_VCF_CHECK
 35 | %define 	GO4K_USE_VCF_MOD_FM
 36 | %define 	GO4K_USE_VCF_HIGH
 37 | %define 	GO4K_USE_VCF_BAND
 38 | %define 	GO4K_USE_VCF_PEAK
 39 | %define 	GO4K_USE_DST_CHECK
 40 | %define		GO4K_USE_DLL_CHORUS_CLAMP
 41 | %define 	GO4K_USE_DLL_DAMP
 42 | %define 	GO4K_USE_DLL_DC_FILTER
 43 | %define 	GO4K_USE_FSTG_CHECK
 44 | %define		GO4K_USE_WAVESHAPER_CLIP
 45 | %define	MAX_DELAY			65536
 46 | %define MAX_WORKSPACE_SLOTS	8
 47 | %define GO4K_BEGIN_CMDDEF(def_name)
 48 | %define GO4K_END_CMDDEF db 0
 49 | %define GO4K_BEGIN_PARAMDEF(def_name)
 50 | %define GO4K_END_PARAMDEF
 51 | GO4K_ENV_ID		equ		1
 52 | %macro	GO4K_ENV 5
 53 | 	db	%1
 54 | 	db	%2
 55 | 	db	%3
 56 | 	db	%4
 57 | 	db	%5
 58 | %endmacro
 59 | %define	ATTAC(val)		val	
 60 | %define	DECAY(val)		val	
 61 | %define	SUSTAIN(val)	val	
 62 | %define	RELEASE(val)	val	
 63 | %define	GAIN(val)		val	
 64 | struc	go4kENV_val
 65 | 	.attac		resd	1
 66 | 	.decay		resd	1
 67 | 	.sustain	resd	1
 68 | 	.release	resd	1
 69 | 	.gain		resd	1
 70 | 	.size
 71 | endstruc
 72 | struc	go4kENV_wrk
 73 | 	.state		resd	1
 74 | 	.level		resd	1
 75 | 	.gm			resd	1
 76 | 	.am			resd	1
 77 | 	.dm			resd	1
 78 | 	.sm			resd	1
 79 | 	.rm			resd	1
 80 | 	.size
 81 | endstruc
 82 | %define ENV_STATE_ATTAC		0
 83 | %define ENV_STATE_DECAY		1
 84 | %define ENV_STATE_SUSTAIN	2
 85 | %define ENV_STATE_RELEASE	3
 86 | %define ENV_STATE_OFF		4
 87 | GO4K_VCO_ID		equ		2
 88 | %macro	GO4K_VCO 8
 89 | 	db	%1
 90 | 	db	%2
 91 | %ifdef GO4K_USE_VCO_PHASE_OFFSET	
 92 | 	db	%3
 93 | %endif	
 94 | %ifdef GO4K_USE_VCO_GATE	
 95 | 	db	%4
 96 | %endif	
 97 | 	db	%5
 98 | %ifdef GO4K_USE_VCO_SHAPE	
 99 | 	db	%6
100 | %endif	
101 | 	db	%7
102 | 	db	%8
103 | %endmacro
104 | %define	TRANSPOSE(val)	val	
105 | %define	DETUNE(val)		val	
106 | %define	PHASE(val)		val	
107 | %define	GATES(val)		val	
108 | %define	COLOR(val)		val	
109 | %define	SHAPE(val)		val 
110 | %define	FLAGS(val)		val	
111 | %define SINE		0x01
112 | %define TRISAW		0x02
113 | %define PULSE		0x04
114 | %define NOISE		0x08
115 | %define LFO			0x10
116 | %define GATE		0x20
117 | struc	go4kVCO_val
118 | 	.transpose	resd	1
119 | 	.detune		resd	1
120 | %ifdef GO4K_USE_VCO_PHASE_OFFSET	
121 | 	.phaseofs	resd	1
122 | %endif	
123 | %ifdef GO4K_USE_VCO_GATE	
124 | 	.gate		resd	1
125 | %endif	
126 | 	.color		resd	1
127 | %ifdef GO4K_USE_VCO_SHAPE	
128 | 	.shape		resd	1
129 | %endif	
130 | 	.gain		resd	1
131 | 	.flags		resd	1	
132 | 	.size
133 | endstruc
134 | struc	go4kVCO_wrk
135 | 	.phase		resd	1
136 | 	.tm			resd	1
137 | 	.dm			resd	1
138 | 	.fm			resd	1
139 | 	.pm			resd	1
140 | 	.cm			resd	1
141 | 	.sm			resd	1
142 | 	.gm			resd	1
143 | 	.size
144 | endstruc
145 | GO4K_VCF_ID		equ		3
146 | %macro	GO4K_VCF 3
147 | 	db	%1
148 | 	db	%2
149 | 	db	%3
150 | %endmacro
151 | %define LOWPASS		0x1
152 | %define HIGHPASS	0x2
153 | %define BANDPASS	0x4
154 | %define	BANDSTOP	0x3
155 | %define ALLPASS		0x7
156 | %define	PEAK		0x8
157 | %define	FREQUENCY(val)	val
158 | %define	RESONANCE(val)	val
159 | %define	VCFTYPE(val)	val
160 | struc	go4kVCF_val
161 | 	.freq		resd	1
162 | 	.res		resd	1
163 | 	.type		resd	1
164 | 	.size
165 | endstruc
166 | struc	go4kVCF_wrk
167 | 	.low		resd	1
168 | 	.high		resd	1
169 | 	.band		resd	1
170 | 	.freq		resd	1
171 | 	.fm			resd	1
172 | 	.rm			resd	1	
173 | 	.size
174 | endstruc
175 | GO4K_DST_ID		equ		4
176 | %macro	GO4K_DST 2
177 | 	db	%1
178 | %ifdef GO4K_USE_DST_SH	
179 | 	db	%2
180 | %endif	
181 | %endmacro
182 | %define	DRIVE(val)		val
183 | %define	SNHFREQ(val)	val
184 | struc	go4kDST_val
185 | 	.drive		resd	1
186 | %ifdef GO4K_USE_DST_SH	
187 | 	.snhfreq	resd	1
188 | %endif	
189 | 	.size
190 | endstruc
191 | struc	go4kDST_wrk
192 | %ifdef GO4K_USE_DST_SH	
193 | 	.out		resd	1
194 | 	.snhphase	resd	1
195 | %endif	
196 | 	.dm			resd	1
197 | 	.sm			resd	1
198 | 	.size
199 | endstruc
200 | GO4K_DLL_ID		equ		5
201 | %macro	GO4K_DLL 8
202 | 	db	%1
203 | 	db	%2
204 | 	db	%3
205 | %ifdef GO4K_USE_DLL_DAMP	
206 | 	db	%4
207 | %endif		
208 | %ifdef GO4K_USE_DLL_CHORUS	
209 | 	db	%5
210 | 	db	%6
211 | %endif
212 | 	db	%7
213 | 	db	%8
214 | %endmacro
215 | %define PREGAIN(val)	val
216 | %define	DRY(val)		val
217 | %define	FEEDBACK(val)	val
218 | %define	DEPTH(val)		val
219 | %define DAMP(val)		val
220 | %define	DELAY(val)		val
221 | %define	COUNT(val)		val
222 | struc	go4kDLL_val
223 | 	.pregain	resd	1
224 | 	.dry		resd	1
225 | 	.feedback	resd	1
226 | %ifdef GO4K_USE_DLL_DAMP	
227 | 	.damp		resd	1	
228 | %endif
229 | %ifdef GO4K_USE_DLL_CHORUS
230 | 	.freq		resd	1
231 | 	.depth
232 | %endif
233 | 	.delay		resd	1
234 | 	.count		resd	1
235 | 	.size
236 | endstruc
237 | struc	go4kDLL_wrk
238 | 	.index		resd	1
239 | 	.store		resd	1
240 | 	.dcin		resd	1
241 | 	.dcout		resd	1
242 | %ifdef GO4K_USE_DLL_CHORUS
243 | 	.phase		resd	1
244 | %endif
245 | 	.buffer		resd	MAX_DELAY
246 | 	.size
247 | endstruc
248 | struc	go4kDLL_wrk2
249 |  .pm			resd	1
250 |  .fm			resd	1
251 |  .im			resd	1
252 |  .dm			resd	1
253 |  .sm			resd	1
254 |  .am			resd	1
255 |  .size
256 | endstruc
257 | GO4K_FOP_ID	equ			6
258 | %macro	GO4K_FOP 1
259 | 	db	%1
260 | %endmacro
261 | %define	OP(val)			val
262 | %define FOP_POP			0x1
263 | %define FOP_ADDP		0x2
264 | %define FOP_MULP		0x3
265 | %define FOP_PUSH		0x4
266 | %define FOP_XCH			0x5
267 | %define FOP_ADD			0x6
268 | %define FOP_MUL			0x7
269 | %define FOP_ADDP2		0x8
270 | %define FOP_LOADNOTE	0x9
271 | struc	go4kFOP_val
272 | 	.flags		resd	1
273 | 	.size
274 | endstruc
275 | struc	go4kFOP_wrk
276 | 	.size
277 | endstruc
278 | GO4K_FST_ID		equ		7
279 | %macro	GO4K_FST 2
280 | 	db	%1
281 | 	db	%2
282 | %endmacro
283 | %define	AMOUNT(val)		val
284 | %define	DEST(val)		val
285 | struc	go4kFST_val
286 | 	.amount		resd	1
287 | 	.op1		resd	1
288 | 	.size
289 | endstruc
290 | struc	go4kFST_wrk
291 | 	.size
292 | endstruc
293 | GO4K_PAN_ID		equ		8
294 | %macro	GO4K_PAN 1
295 | %ifdef GO4K_USE_PAN
296 | 	db	%1
297 | %endif
298 | %endmacro
299 | %define	PANNING(val)	val
300 | struc	go4kPAN_val
301 | %ifdef GO4K_USE_PAN
302 | 	.panning	resd	1
303 | %endif
304 | 	.size
305 | endstruc
306 | struc	go4kPAN_wrk
307 | 	.pm			resd	1
308 | 	.size
309 | endstruc
310 | GO4K_OUT_ID		equ		9
311 | %macro	GO4K_OUT 2
312 | 	db	%1
313 | %ifdef GO4K_USE_GLOBAL_DLL	
314 | 	db	%2
315 | %endif	
316 | %endmacro
317 | %define	AUXSEND(val)	val
318 | struc	go4kOUT_val
319 | 	.gain		resd	1
320 | %ifdef GO4K_USE_GLOBAL_DLL	
321 | 	.auxsend	resd	1
322 | %endif
323 | 	.size
324 | endstruc
325 | struc	go4kOUT_wrk
326 | 	.am			resd	1
327 | 	.gm			resd	1
328 | 	.size
329 | endstruc
330 | GO4K_ACC_ID		equ		10
331 | %macro	GO4K_ACC 1
332 | 	db	%1
333 | %endmacro
334 | %define OUTPUT			0
335 | %define	AUX				8
336 | %define ACCTYPE(val)	val
337 | struc	go4kACC_val
338 | 	.acctype	resd	1
339 | 	.size
340 | endstruc
341 | struc	go4kACC_wrk
342 | 	.size
343 | endstruc
344 | %ifdef GO4K_USE_FLD
345 | GO4K_FLD_ID	equ		11
346 | %macro	GO4K_FLD 1
347 | 	db	
348 | %endmacro
349 | %define	VALUE(val)	val
350 | struc	go4kFLD_val
351 | 	.value		resd	1
352 | 	.size
353 | endstruc
354 | struc	go4kFLD_wrk
355 | 	.vm			resd	1
356 | 	.size
357 | endstruc
358 | %endif
359 | %ifdef GO4K_USE_FSTG
360 | GO4K_FSTG_ID	equ		12
361 | %macro	GO4K_FSTG 2
362 | 	db	%1
363 | 	dd	%2
364 | %endmacro
365 | struc	go4kFSTG_val
366 | 	.amount		resd	1
367 | 	.op1		resd	1
368 | 	.size
369 | endstruc
370 | struc	go4kFSTG_wrk
371 | 	.size
372 | endstruc
373 | %endif
374 | struc	go4k_instrument
375 | 	.release	resd	1
376 | 	.note		resd	1
377 | 	.workspace	resd	256
378 | 	.dlloutl	resd	1
379 | 	.dlloutr	resd	1
380 | 	.outl		resd	1
381 | 	.outr		resd	1
382 | 	.size
383 | endstruc
384 | struc	go4k_synth
385 | 	.instruments	resb	go4k_instrument.size * MAX_INSTRUMENTS * MAX_VOICES
386 | 	.global			resb	go4k_instrument.size * MAX_VOICES
387 | 	.size
388 | endstruc
389 | %ifdef USE_SECTIONS
390 | section .g4kmuc1 data align=1
391 | %else
392 | section .data align=1
393 | %endif
394 | go4k_patterns
395 | 	db	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
396 | 	db	72, HLD, HLD, HLD, 0, 0, 0, 0, 79, HLD, HLD, HLD, 0, 0, 0, 0, 
397 | 	db	67, HLD, HLD, HLD, HLD, HLD, HLD, HLD, 0, 0, 0, 0, 0, 0, 0, 0, 
398 | 	db	76, HLD, HLD, HLD, 0, 0, 0, 0, 84, HLD, HLD, HLD, 0, 0, 0, 0, 
399 | 	db	69, HLD, HLD, HLD, HLD, HLD, HLD, HLD, 0, 0, 0, 0, 0, 0, 0, 0, 
400 | 	db	72, HLD, HLD, HLD, HLD, HLD, HLD, HLD, 0, 0, 0, 0, 0, 0, 0, 0, 
401 | 	db	52, 64, 0, 52, 64, 0, 52, 64, 52, 64, 0, 52, 64, 0, 52, 64, 
402 | 	db	57, 69, 0, 57, 69, 0, 57, 69, 57, 69, 0, 57, 69, 0, 57, 69, 
403 | 	db	57, 69, 0, 57, 69, 0, 57, 69, 57, 64, 0, 57, 69, 0, 57, 69, 
404 | 	db	48, 60, 0, 48, 60, 0, 48, 60, 48, 60, 0, 48, 60, 0, 48, 60, 
405 | 	db	45, 57, 0, 45, 57, 0, 45, 57, 45, 57, 0, 45, 57, 0, 45, 57, 
406 | 	db	48, 60, 0, 48, 60, 0, 48, 60, 0, 0, 0, 0, 0, 0, 0, 0, 
407 | 	db	57, HLD, HLD, HLD, HLD, HLD, HLD, HLD, 0, 0, 0, 0, 0, 0, 0, 0, 
408 | 	db	0, 0, 0, 0, 60, HLD, HLD, HLD, HLD, HLD, HLD, HLD, 60, HLD, HLD, HLD, 
409 | 	db	HLD, HLD, HLD, HLD, 60, HLD, HLD, HLD, HLD, HLD, HLD, HLD, 60, HLD, HLD, HLD, 
410 | 	db	HLD, HLD, HLD, HLD, 60, HLD, HLD, HLD, 0, 0, 0, 0, 0, 0, 0, 0, 
411 | 	db	60, HLD, 0, 0, 0, 0, 60, HLD, 0, 0, 60, HLD, 60, HLD, 0, 0, 
412 | 	db	0, 0, 0, 0, 60, HLD, 0, 0, 0, 0, 0, 0, 60, HLD, 0, 0, 
413 | 	db	60, HLD, 0, 0, 0, 0, 60, HLD, 0, 0, 0, 0, 0, 0, 0, 0, 
414 | go4k_patterns_end
415 | %ifdef USE_SECTIONS
416 | section .g4kmuc2 data align=1
417 | %else
418 | section .data
419 | %endif
420 | go4k_pattern_lists
421 | Instrument0List		db	1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 5, 0, 0, 0, 0, 
422 | Instrument1List		db	0, 0, 0, 0, 6, 6, 7, 8, 9, 9, 10, 10, 6, 6, 7, 8, 9, 9, 10, 10, 6, 6, 6, 6, 9, 9, 10, 10, 9, 9, 10, 10, 9, 9, 10, 10, 9, 9, 10, 10, 9, 9, 10, 10, 9, 9, 10, 10, 11, 0, 0, 0, 0, 
423 | Instrument2List		db	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 0, 0, 0, 
424 | Instrument3List		db	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 0, 0, 0, 0, 
425 | Instrument4List		db	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 18, 0, 0, 0, 0, 
426 | go4k_pattern_lists_end
427 | %ifdef USE_SECTIONS
428 | section .g4kmuc3 data align=1
429 | %else
430 | section .data
431 | %endif
432 | go4k_synth_instructions
433 | GO4K_BEGIN_CMDDEF(Instrument0)
434 | 	db GO4K_ENV_ID
435 | 	db GO4K_FST_ID
436 | 	db GO4K_VCO_ID
437 | 	db GO4K_VCO_ID
438 | 	db GO4K_VCO_ID
439 | 	db GO4K_FST_ID
440 | 	db GO4K_FST_ID
441 | 	db GO4K_FOP_ID
442 | 	db GO4K_FOP_ID
443 | 	db GO4K_FOP_ID
444 | 	db GO4K_VCF_ID
445 | 	db GO4K_VCF_ID
446 | 	db GO4K_DST_ID
447 | 	db GO4K_PAN_ID
448 | 	db GO4K_DLL_ID
449 | 	db GO4K_FOP_ID
450 | 	db GO4K_DLL_ID
451 | 	db GO4K_FOP_ID
452 | 	db GO4K_OUT_ID
453 | GO4K_END_CMDDEF
454 | GO4K_BEGIN_CMDDEF(Instrument1)
455 | 	db GO4K_ENV_ID
456 | 	db GO4K_FST_ID
457 | 	db GO4K_VCO_ID
458 | 	db GO4K_VCO_ID
459 | 	db GO4K_VCO_ID
460 | 	db GO4K_FST_ID
461 | 	db GO4K_FST_ID
462 | 	db GO4K_FOP_ID
463 | 	db GO4K_FOP_ID
464 | 	db GO4K_FOP_ID
465 | 	db GO4K_VCF_ID
466 | 	db GO4K_VCF_ID
467 | 	db GO4K_DST_ID
468 | 	db GO4K_PAN_ID
469 | 	db GO4K_DLL_ID
470 | 	db GO4K_FOP_ID
471 | 	db GO4K_DLL_ID
472 | 	db GO4K_FOP_ID
473 | 	db GO4K_OUT_ID
474 | GO4K_END_CMDDEF
475 | GO4K_BEGIN_CMDDEF(Instrument2)
476 | 	db GO4K_ENV_ID
477 | 	db GO4K_FSTG_ID
478 | 	db GO4K_FOP_ID
479 | GO4K_END_CMDDEF
480 | GO4K_BEGIN_CMDDEF(Instrument3)
481 | 	db GO4K_ENV_ID
482 | 	db GO4K_FST_ID
483 | 	db GO4K_VCO_ID
484 | 	db GO4K_FOP_ID
485 | 	db GO4K_VCF_ID
486 | 	db GO4K_PAN_ID
487 | 	db GO4K_OUT_ID
488 | GO4K_END_CMDDEF
489 | GO4K_BEGIN_CMDDEF(Instrument4)
490 | 	db GO4K_ENV_ID
491 | 	db GO4K_FST_ID
492 | 	db GO4K_ENV_ID
493 | 	db GO4K_DST_ID
494 | 	db GO4K_FST_ID
495 | 	db GO4K_FOP_ID
496 | 	db GO4K_VCO_ID
497 | 	db GO4K_FOP_ID
498 | 	db GO4K_PAN_ID
499 | 	db GO4K_OUT_ID
500 | GO4K_END_CMDDEF
501 | GO4K_BEGIN_CMDDEF(Global)
502 | 	db GO4K_ACC_ID
503 | 	db GO4K_DLL_ID
504 | 	db GO4K_FOP_ID
505 | 	db GO4K_DLL_ID
506 | 	db GO4K_FOP_ID
507 | 	db GO4K_ACC_ID
508 | 	db GO4K_FOP_ID
509 | 	db GO4K_OUT_ID
510 | GO4K_END_CMDDEF
511 | go4k_synth_instructions_end
512 | %ifdef USE_SECTIONS
513 | section .g4kmuc4 data align=1
514 | %else
515 | section .data
516 | %endif
517 | go4k_synth_parameter_values
518 | GO4K_BEGIN_PARAMDEF(Instrument0)
519 | 	GO4K_ENV	ATTAC(96),DECAY(96),SUSTAIN(96),RELEASE(96),GAIN(128)
520 | 	GO4K_FST	AMOUNT(64),DEST(0*MAX_WORKSPACE_SLOTS+2)
521 | 	GO4K_VCO	TRANSPOSE(64),DETUNE(60),PHASE(32),GATES(85),COLOR(78),SHAPE(64),GAIN(128),FLAGS(PULSE)
522 | 	GO4K_VCO	TRANSPOSE(64),DETUNE(72),PHASE(32),GATES(85),COLOR(96),SHAPE(64),GAIN(128),FLAGS(TRISAW)
523 | 	GO4K_VCO	TRANSPOSE(40),DETUNE(64),PHASE(0),GATES(85),COLOR(64),SHAPE(64),GAIN(128),FLAGS(SINE|LFO)
524 | 	GO4K_FST	AMOUNT(68),DEST(2*MAX_WORKSPACE_SLOTS+2)
525 | 	GO4K_FST	AMOUNT(61),DEST(3*MAX_WORKSPACE_SLOTS+2)
526 | 	GO4K_FOP	OP(FOP_POP)
527 | 	GO4K_FOP	OP(FOP_ADDP)
528 | 	GO4K_FOP	OP(FOP_MULP)
529 | 	GO4K_VCF	FREQUENCY(26),RESONANCE(128),VCFTYPE(PEAK)
530 | 	GO4K_VCF	FREQUENCY(64),RESONANCE(64),VCFTYPE(LOWPASS)
531 | 	GO4K_DST	DRIVE(104), SNHFREQ(128)
532 | 	GO4K_PAN	PANNING(64)
533 | 	GO4K_DLL	PREGAIN(96),DRY(128),FEEDBACK(96),DAMP(64),FREQUENCY(0),DEPTH(0),DELAY(16),COUNT(1)
534 | 	GO4K_FOP	OP(FOP_XCH)
535 | 	GO4K_DLL	PREGAIN(96),DRY(128),FEEDBACK(80),DAMP(64),FREQUENCY(0),DEPTH(0),DELAY(17),COUNT(1)
536 | 	GO4K_FOP	OP(FOP_XCH)
537 | 	GO4K_OUT	GAIN(0), AUXSEND(64)
538 | GO4K_END_PARAMDEF
539 | GO4K_BEGIN_PARAMDEF(Instrument1)
540 | 	GO4K_ENV	ATTAC(32),DECAY(64),SUSTAIN(32),RELEASE(32),GAIN(128)
541 | 	GO4K_FST	AMOUNT(118),DEST(0*MAX_WORKSPACE_SLOTS+2)
542 | 	GO4K_VCO	TRANSPOSE(64),DETUNE(60),PHASE(32),GATES(85),COLOR(78),SHAPE(64),GAIN(128),FLAGS(TRISAW)
543 | 	GO4K_VCO	TRANSPOSE(64),DETUNE(72),PHASE(32),GATES(85),COLOR(96),SHAPE(64),GAIN(128),FLAGS(TRISAW)
544 | 	GO4K_VCO	TRANSPOSE(40),DETUNE(64),PHASE(0),GATES(85),COLOR(64),SHAPE(64),GAIN(128),FLAGS(SINE|LFO)
545 | 	GO4K_FST	AMOUNT(68),DEST(2*MAX_WORKSPACE_SLOTS+2)
546 | 	GO4K_FST	AMOUNT(61),DEST(3*MAX_WORKSPACE_SLOTS+2)
547 | 	GO4K_FOP	OP(FOP_POP)
548 | 	GO4K_FOP	OP(FOP_ADDP)
549 | 	GO4K_FOP	OP(FOP_MULP)
550 | 	GO4K_VCF	FREQUENCY(26),RESONANCE(128),VCFTYPE(PEAK)
551 | 	GO4K_VCF	FREQUENCY(101),RESONANCE(24),VCFTYPE(BANDPASS)
552 | 	GO4K_DST	DRIVE(104), SNHFREQ(128)
553 | 	GO4K_PAN	PANNING(64)
554 | 	GO4K_DLL	PREGAIN(96),DRY(128),FEEDBACK(96),DAMP(64),FREQUENCY(0),DEPTH(0),DELAY(16),COUNT(1)
555 | 	GO4K_FOP	OP(FOP_XCH)
556 | 	GO4K_DLL	PREGAIN(96),DRY(128),FEEDBACK(80),DAMP(64),FREQUENCY(0),DEPTH(0),DELAY(17),COUNT(1)
557 | 	GO4K_FOP	OP(FOP_XCH)
558 | 	GO4K_OUT	GAIN(64), AUXSEND(64)
559 | GO4K_END_PARAMDEF
560 | GO4K_BEGIN_PARAMDEF(Instrument2)
561 | 	GO4K_ENV	ATTAC(80),DECAY(128),SUSTAIN(128),RELEASE(80),GAIN(128)
562 | 	GO4K_FSTG	AMOUNT(22),DEST(1*go4k_instrument.size*MAX_VOICES+11*MAX_WORKSPACE_SLOTS*4+4*4+go4k_instrument.workspace)
563 | 	GO4K_FOP	OP(FOP_POP)
564 | GO4K_END_PARAMDEF
565 | GO4K_BEGIN_PARAMDEF(Instrument3)
566 | 	GO4K_ENV	ATTAC(0),DECAY(75),SUSTAIN(0),RELEASE(0),GAIN(32)
567 | 	GO4K_FST	AMOUNT(128),DEST(0*MAX_WORKSPACE_SLOTS+2)
568 | 	GO4K_VCO	TRANSPOSE(64),DETUNE(64),PHASE(64),GATES(85),COLOR(64),SHAPE(64),GAIN(128),FLAGS(NOISE)
569 | 	GO4K_FOP	OP(FOP_MULP)
570 | 	GO4K_VCF	FREQUENCY(63),RESONANCE(64),VCFTYPE(LOWPASS)
571 | 	GO4K_PAN	PANNING(64)
572 | 	GO4K_OUT	GAIN(64), AUXSEND(0)
573 | GO4K_END_PARAMDEF
574 | GO4K_BEGIN_PARAMDEF(Instrument4)
575 | 	GO4K_ENV	ATTAC(0),DECAY(64),SUSTAIN(96),RELEASE(64),GAIN(128)
576 | 	GO4K_FST	AMOUNT(128),DEST(0*MAX_WORKSPACE_SLOTS+2)
577 | 	GO4K_ENV	ATTAC(0),DECAY(70),SUSTAIN(0),RELEASE(0),GAIN(128)
578 | 	GO4K_DST	DRIVE(32), SNHFREQ(128)
579 | 	GO4K_FST	AMOUNT(80),DEST(6*MAX_WORKSPACE_SLOTS+1)
580 | 	GO4K_FOP	OP(FOP_POP)
581 | 	GO4K_VCO	TRANSPOSE(45),DETUNE(64),PHASE(0),GATES(85),COLOR(64),SHAPE(66),GAIN(128),FLAGS(TRISAW)
582 | 	GO4K_FOP	OP(FOP_MULP)
583 | 	GO4K_PAN	PANNING(64)
584 | 	GO4K_OUT	GAIN(128), AUXSEND(0)
585 | GO4K_END_PARAMDEF
586 | GO4K_BEGIN_PARAMDEF(Global)
587 | 	GO4K_ACC	ACCTYPE(AUX)
588 | 	GO4K_DLL	PREGAIN(40),DRY(128),FEEDBACK(125),DAMP(64),FREQUENCY(0),DEPTH(0),DELAY(0),COUNT(8)
589 | 	GO4K_FOP	OP(FOP_XCH)
590 | 	GO4K_DLL	PREGAIN(40),DRY(128),FEEDBACK(125),DAMP(64),FREQUENCY(0),DEPTH(0),DELAY(8),COUNT(8)
591 | 	GO4K_FOP	OP(FOP_XCH)
592 | 	GO4K_ACC	ACCTYPE(OUTPUT)
593 | 	GO4K_FOP	OP(FOP_ADDP2)
594 | 	GO4K_OUT	GAIN(64), AUXSEND(0)
595 | GO4K_END_PARAMDEF
596 | go4k_synth_parameter_values_end
597 | %ifdef USE_SECTIONS
598 | section .g4kmuc5 data align=1
599 | %else
600 | section .data
601 | %endif
602 | %ifdef GO4K_USE_DLL
603 | global _go4k_delay_times
604 | _go4k_delay_times
605 | 	dw 1116
606 | 	dw 1188
607 | 	dw 1276
608 | 	dw 1356
609 | 	dw 1422
610 | 	dw 1492
611 | 	dw 1556
612 | 	dw 1618
613 | 	dw 1140
614 | 	dw 1212
615 | 	dw 1300
616 | 	dw 1380
617 | 	dw 1446
618 | 	dw 1516
619 | 	dw 1580
620 | 	dw 1642
621 | 	dw 13230
622 | 	dw 26460
623 | %endif
624 | 


--------------------------------------------------------------------------------
/audio/4klang.asm:
--------------------------------------------------------------------------------
   1 | bits	32
   2 | 
   3 | %define WRK	ebp				; // alias for unit workspace
   4 | %define	VAL esi				; // alias for unit values (transformed/untransformed)
   5 | %define COM ebx				; // alias for instrument opcodes
   6 | 
   7 | %include "4klang.inc"
   8 | 
   9 | ;// conditional defines
  10 | 
  11 | %ifdef GO4K_USE_VCO_SHAPE
  12 | 	%define INCLUDE_WAVESHAPER
  13 | %endif
  14 | %ifdef GO4K_USE_DST
  15 | 	%define INCLUDE_WAVESHAPER
  16 | %endif
  17 | 
  18 | %ifdef GO4K_USE_VCO_MOD_PM	
  19 | 	%define PHASE_RENORMALIZE
  20 | %endif
  21 | %ifdef GO4K_USE_VCO_PHASE_OFFSET
  22 | 	%define PHASE_RENORMALIZE
  23 | %endif
  24 | 
  25 | %ifdef GO4K_USE_ENVELOPE_RECORDINGS
  26 | 	%define GO4K_USE_BUFFER_RECORDINGS
  27 | %endif
  28 | %ifdef GO4K_USE_NOTE_RECORDINGS
  29 | 	%define GO4K_USE_BUFFER_RECORDINGS
  30 | %endif
  31 | 
  32 | ; //========================================================================================
  33 | ; //	.bss section
  34 | ; //========================================================================================
  35 | %ifdef USE_SECTIONS
  36 | section		.g4kbss1	bss		align=1
  37 | %else
  38 | section .bss
  39 | %endif
  40 | 
  41 | ; // the one and only synth object
  42 | %if MAX_VOICES > 1
  43 | go4k_voiceindex 		resd	16
  44 | %endif
  45 | go4k_transformed_values	resd	16
  46 | go4k_synth_wrk			resb	go4k_synth.size
  47 | global _go4k_delay_buffer_ofs
  48 | _go4k_delay_buffer_ofs	resd	1
  49 | global _go4k_delay_buffer		
  50 | _go4k_delay_buffer		resd	117*go4kDLL_wrk.size
  51 | 
  52 | %ifdef GO4K_USE_ENVELOPE_RECORDINGS
  53 | global __4klang_envelope_buffer
  54 | __4klang_envelope_buffer	resd	((MAX_SAMPLES)/8) ; // samples every 256 samples and stores 16*2 = 32 values
  55 | %endif
  56 | %ifdef GO4K_USE_NOTE_RECORDINGS
  57 | global __4klang_note_buffer
  58 | __4klang_note_buffer		resd	((MAX_SAMPLES)/8) ; // samples every 256 samples and stores 16*2 = 32 values
  59 | %endif
  60 | 
  61 | ; //========================================================================================
  62 | ; //	.g4kdat section (initialized data for go4k)
  63 | ; //========================================================================================
  64 | %ifdef USE_SECTIONS
  65 | section		.g4kdat1	data	align=1
  66 | %else
  67 | section .data
  68 | %endif
  69 | 
  70 | ; // some synth constants
  71 | go4k_synth_commands		dd	0
  72 | 						dd	_go4kENV_func@0
  73 | 						dd	_go4kVCO_func@0					
  74 | 						dd	_go4kVCF_func@0
  75 | 						dd	_go4kDST_func@0
  76 | 						dd	_go4kDLL_func@0
  77 | 						dd	_go4kFOP_func@0
  78 | 						dd	_go4kFST_func@0
  79 | 						dd	_go4kPAN_func@0
  80 | 						dd	_go4kOUT_func@0
  81 | 						dd	_go4kACC_func@0		
  82 | 						dd	_go4kFLD_func@0
  83 | %ifdef	GO4K_USE_FSTG						
  84 | 						dd	_go4kFSTG_func@0
  85 | %endif						
  86 | 
  87 | %ifdef USE_SECTIONS						
  88 | section		.g4kdat2	data	align=1
  89 | %else
  90 | section .data
  91 | %endif
  92 | 
  93 | %ifdef GO4K_USE_16BIT_OUTPUT
  94 | c_32767					dd		32767.0
  95 | %endif
  96 | c_i128					dd		0.0078125
  97 | c_RandDiv				dd		65536*32768
  98 | c_0_5					dd		0.5
  99 | %ifdef GO4K_USE_VCO_GATE
 100 | c_16					dd		16.0
 101 | %endif
 102 | %ifdef GO4K_USE_DLL_CHORUS
 103 | DLL_DEPTH				dd		1024.0
 104 | %endif
 105 | %ifdef GO4K_USE_DLL_DC_FILTER
 106 | c_dc_const				dd		0.99609375		; R = 1 - (pi*2 * frequency /samplerate) 
 107 | %else
 108 | 	%ifdef GO4K_USE_VCO_GATE
 109 | c_dc_const				dd		0.99609375		; R = 1 - (pi*2 * frequency /samplerate) 
 110 | 	%endif
 111 | %endif
 112 | global _RandSeed
 113 | _RandSeed				dd		1
 114 | c_24					dd		24
 115 | c_i12					dd		0x3DAAAAAA
 116 | FREQ_NORMALIZE			dd		0.000092696138	; // 220.0/(2^(69/12)) / 44100.0
 117 | global _LFO_NORMALIZE
 118 | _LFO_NORMALIZE			dd		DEF_LFO_NORMALIZE
 119 | %ifdef GO4K_USE_GROOVE_PATTERN
 120 | go4k_groove_pattern		dw		0011100111001110b
 121 | %endif
 122 | 
 123 | ; //========================================================================================
 124 | ; //	.crtemui section (emulates crt functions)
 125 | ; //========================================================================================
 126 | %ifdef USE_SECTIONS
 127 | section		.crtemui	code	align=1
 128 | %else
 129 | section .text
 130 | %endif
 131 | 
 132 | export_func	FloatRandomNumber@0
 133 | 	imul    eax,dword [_RandSeed],16007
 134 | 	mov     dword [_RandSeed], eax 
 135 | 	fild	dword [_RandSeed]
 136 | 	fidiv	dword [c_RandDiv]
 137 | 	ret
 138 | 	
 139 | ; //========================================================================================
 140 | ; //	.g4kcod* sections (code for go4k)
 141 | ; //========================================================================================
 142 | 
 143 | %ifdef INCLUDE_WAVESHAPER
 144 | 
 145 | %ifdef USE_SECTIONS
 146 | section		.g4kcod2	code	align=1
 147 | %else
 148 | section .text
 149 | %endif
 150 | ; //----------------------------------------------------------------------------------------
 151 | ; //	Waveshaper function
 152 | ; //----------------------------------------------------------------------------------------
 153 | ; //	Input :		st0		:	shaping coeff
 154 | ; //				st1		:	input
 155 | ; //	Output:		st0		:	result
 156 | ; //----------------------------------------------------------------------------------------
 157 | 	
 158 | go4kWaveshaper:
 159 | %ifdef GO4K_USE_WAVESHAPER_CLIP
 160 | 	fxch
 161 | 	fld1									; //	1		val
 162 | 	fucomi	st1								; //	1		val
 163 | 	jbe		short go4kWaveshaper_clip
 164 | 	fchs									; //	-1		val
 165 | 	fucomi	st1								; //	-1		val
 166 | 	fcmovb	st0, st1						; //	val		-1		(if val > -1)
 167 | go4kWaveshaper_clip:
 168 | 	fstp	st1								; //	newval
 169 | 	fxch
 170 | %endif	
 171 | 	fsub	dword [c_0_5]
 172 | 	fadd	st0
 173 | 	fst		dword [esp-4]					; // amnt	in
 174 | 	fadd	st0								; // 2*amnt	in
 175 | 	fld1									; // 1		2*amnt	in
 176 | 	fsub	dword [esp-4]					; // 1-amnt 2*amnt	in
 177 | 	fdivp	st1, st0						; // k		in
 178 | 	fld		st1								; // sin	k		in
 179 | 	fabs									; // a(in)	k		in
 180 | 	fmul	st1								; // k*a(in)	k	in
 181 | 	fld1	
 182 | 	faddp	st1, st0						; // 1+k*a(in)	k	in
 183 | 	fxch	st1								; // k		1+k*a(in)		in
 184 | 	fld1
 185 | 	faddp	st1, st0						; // 1+k	1+k*a(in)		in
 186 | 	fmulp	st2								; // 1+k*a(in)		(1+k)*in
 187 | 	fdivp	st1, st0						; // out		
 188 | 	ret
 189 | 
 190 | %endif
 191 | 
 192 | %ifdef USE_SECTIONS
 193 | section		.g4kcod3	code	align=1
 194 | %else
 195 | section .text
 196 | %endif
 197 | ; //----------------------------------------------------------------------------------------
 198 | ; //	unit values preparation/transform
 199 | ; //----------------------------------------------------------------------------------------
 200 | go4kTransformValues:
 201 | 	push	ecx
 202 | 	xor		ecx, ecx
 203 | 	xor		eax, eax
 204 | 	mov		edx, go4k_transformed_values
 205 | go4kTransformValues_loop:	
 206 | 	lodsb	
 207 | 	push	eax
 208 | 	fild	dword [esp]
 209 | 	fmul	dword [c_i128]
 210 | 	fstp	dword [edx+ecx*4]
 211 | 	pop		eax
 212 | 	inc		ecx
 213 | 	cmp		ecx, dword [esp+8]
 214 | 	jl		go4kTransformValues_loop	
 215 | 	pop		ecx
 216 | 	ret		4
 217 | 
 218 | %ifdef USE_SECTIONS	
 219 | section		.g4kcod4	code	align=1
 220 | %else
 221 | section .text
 222 | %endif
 223 | ; //----------------------------------------------------------------------------------------
 224 | ; //	Envelope param mapping
 225 | ; //----------------------------------------------------------------------------------------
 226 | go4kENVMap:
 227 | 	fld		dword [edx+eax*4]
 228 | %ifdef GO4K_USE_ENV_MOD_ADR	
 229 | 	fadd	dword [WRK+go4kENV_wrk.am+eax*4]
 230 | %endif	
 231 | 	fimul	dword [c_24]
 232 | 	fchs
 233 | ; //----------------------------------------------------------------------------------------
 234 | ; //	Power function (2^x)
 235 | ; //----------------------------------------------------------------------------------------
 236 | ; //	Input :		st0		:	base
 237 | ; //				st1		:	exponent
 238 | ; //	Output:		st0		:	result
 239 | ; //----------------------------------------------------------------------------------------
 240 | export_func	Power@0	; // base				exp	
 241 | 	fld1
 242 | 	fadd	st0	
 243 | 	fyl2x				; // log2_base
 244 | 	fld1				; // 1					log2_base
 245 | 	fld		st1			; // log2_base			1					log2_base
 246 | 	fprem				; // (frac)log2_base	1					log2_base
 247 | 	f2xm1				; // 2 ^ '' -	1		1					log2_base
 248 | 	faddp	st1, st0	; // 2 ^ ''			(int)log2_base
 249 | 	fscale
 250 | 	fstp	st1
 251 | 	ret
 252 | 	
 253 | %ifdef USE_SECTIONS
 254 | section		.g4kcoda	code	align=1
 255 | %else
 256 | section .text
 257 | %endif
 258 | ; //----------------------------------------------------------------------------------------
 259 | ; //	ENV Tick
 260 | ; //----------------------------------------------------------------------------------------
 261 | ; // IN		:		WRK	= unit workspace
 262 | ; // IN		:		VAL	= unit values
 263 | ; // IN		:		ecx	= global workspace
 264 | ; // OUT	:		
 265 | ; // DIRTY	:		eax
 266 | ; //----------------------------------------------------------------------------------------
 267 | export_func	go4kENV_func@0
 268 | 	push	5
 269 | 	call	go4kTransformValues
 270 | %ifdef GO4K_USE_ENV_CHECK
 271 | ; check if current note still active
 272 | 	mov		eax, dword [ecx-4]
 273 | 	test	eax, eax
 274 | 	jne		go4kENV_func_do
 275 | 	fldz
 276 | 	ret
 277 | %endif
 278 | go4kENV_func_do:
 279 | 	mov		eax, dword [ecx-8]					; // is the instrument in release mode (note off)?
 280 | 	test	eax, eax
 281 | 	je		go4kENV_func_process
 282 | 	mov		al, ENV_STATE_RELEASE
 283 | 	mov		dword [WRK+go4kENV_wrk.state], eax
 284 | go4kENV_func_process:	
 285 | 	mov		eax, dword [WRK+go4kENV_wrk.state]
 286 | 	fld		dword [WRK+go4kENV_wrk.level]		; //	val		-
 287 | ; // check for sustain state	
 288 | 	cmp		al, ENV_STATE_SUSTAIN
 289 | 	je		short go4kENV_func_leave2
 290 | go4kENV_func_attac:
 291 | 	cmp		al, ENV_STATE_ATTAC
 292 | 	jne		short go4kENV_func_decay
 293 | 	call	go4kENVMap						; //	newval
 294 | 	faddp	st1, st0
 295 | ; // check for end of attac
 296 | 	fld1									; //	1		newval
 297 | 	fucomi	st1								; //	1		newval
 298 | 	fcmovnb	st0, st1						; //	newval	1		(if newval < 1)
 299 | 	jbe		short go4kENV_func_statechange
 300 | go4kENV_func_decay:
 301 | 	cmp		al, ENV_STATE_DECAY
 302 | 	jne		short go4kENV_func_release		
 303 | 	call	go4kENVMap						; //	newval
 304 | 	fsubp	st1, st0
 305 | ; // check for end of decay
 306 | 	fld		dword [edx+go4kENV_val.sustain]	; //	sustain	newval
 307 | 	fucomi	st1								; //	sustain newval
 308 | 	fcmovb	st0, st1						; //	newval	sustain	(if newval > sustain)
 309 | 	jnc		short go4kENV_func_statechange
 310 | go4kENV_func_release:
 311 | ; // release state?
 312 | 	cmp		al, ENV_STATE_RELEASE
 313 | 	jne		short go4kENV_func_leave
 314 | 	call	go4kENVMap						; //	newval
 315 | 	fsubp	st1, st0
 316 | ; // check for end of release
 317 | 	fldz									; //	0		newval
 318 | 	fucomi	st1								; //	0		newval
 319 | 	fcmovb	st0, st1						; //	newval	0	(if newval > 0)
 320 | 	jc		short go4kENV_func_leave
 321 | go4kENV_func_statechange:					; //	newval
 322 | 	inc		dword [WRK+go4kENV_wrk.state]
 323 | go4kENV_func_leave:						; //	newval	bla
 324 | 	fstp	st1	
 325 | ; // store new env value
 326 | 	fst		dword [WRK+go4kENV_wrk.level]
 327 | go4kENV_func_leave2:	
 328 | ; // mul by gain
 329 | %ifdef GO4K_USE_ENV_MOD_GM
 330 | 	fld		dword [edx+go4kENV_val.gain]
 331 | 	fadd	dword [WRK+go4kENV_wrk.gm]
 332 | 	fmulp	st1, st0
 333 | %else
 334 | 	fmul	dword [edx+go4kENV_val.gain]
 335 | %endif
 336 | 	ret
 337 | 
 338 | 
 339 | ; //----------------------------------------------------------------------------------------
 340 | ; //	VCO Tick
 341 | ; //----------------------------------------------------------------------------------------
 342 | ; // IN		:		WRK	= unit workspace
 343 | ; // IN		:		VAL	= unit values
 344 | ; // IN		:		ecx	= global workspace
 345 | ; // OUT	:		
 346 | ; // DIRTY	:		eax
 347 | ; //----------------------------------------------------------------------------------------
 348 | %ifdef USE_SECTIONS
 349 | section		.g4kcodp	code	align=1
 350 | %else
 351 | section .text
 352 | %endif
 353 | go4kVCO_pulse:
 354 | 	fucomi	st1								; // c		p
 355 | 	fld1
 356 | 	jnc		short go4kVCO_func_pulse_up		; // +1		c		p
 357 | 	fchs									; // -1		c		p
 358 | go4kVCO_func_pulse_up:
 359 | 	fstp	st1								; // +-1	p
 360 | 	fstp	st1								; // +-1
 361 | 	ret
 362 | 
 363 | %ifdef USE_SECTIONS	
 364 | section		.g4kcodt	code	align=1	
 365 | %else
 366 | section .text
 367 | %endif
 368 | go4kVCO_trisaw:
 369 | 	fucomi	st1								; // c		p
 370 | 	jnc		short go4kVCO_func_trisaw_up
 371 | 	fld1									; // 1		c		p
 372 | 	fsubr	st2, st0						; // 1		c		1-p
 373 | 	fsubrp	st1, st0						; // 1-c	1-p
 374 | go4kVCO_func_trisaw_up:
 375 | 	fdivp	st1, st0						; // tp'/tc	
 376 | 	fadd	st0								; // 2*''	
 377 | 	fld1									; // 1		2*''	
 378 | 	fsubp	st1, st0						; // 2*''-1
 379 | 	ret
 380 | 
 381 | %ifdef USE_SECTIONS	
 382 | section		.g4kcods	code	align=1		
 383 | %else
 384 | section .text
 385 | %endif	
 386 | go4kVCO_sine:	
 387 | 	fxch									; // p		c
 388 | 	fstp	st1								; // p
 389 | 	fldpi									; // pi		p
 390 | 	fadd	st0								; // 2*pi	p
 391 | 	fmulp	st1, st0						; // 2*pi*p
 392 | 	fsin									; // sin(2*pi*p)
 393 | 	ret	
 394 | 
 395 | %ifdef GO4K_USE_VCO_GATE
 396 | %ifdef USE_SECTIONS	
 397 | section		.g4kcodq	code	align=1		
 398 | %else
 399 | section .text
 400 | %endif	
 401 | go4kVCO_gate:	
 402 | 	fxch									; // p		c
 403 | 	fstp	st1								; // p		
 404 | 	fmul	dword [c_16]					; // p'
 405 | 	push	eax
 406 | 	push	eax
 407 | 	fistp	dword [esp]						; // -
 408 | 	fld1									; // 1
 409 | 	pop		eax
 410 | 	and		al, 0xf
 411 | 	bt		word [VAL-5],ax
 412 | 	jc		go4kVCO_gate_bit
 413 | 	fsub	st0, st0						; // 0
 414 | go4kVCO_gate_bit:
 415 | 	fld		dword [WRK+go4kVCO_wrk.cm]		; // f		x
 416 | 	fsub	st1								; // f-x	x
 417 | 	fmul	dword [c_dc_const]				; // c(f-x)	x
 418 | 	faddp	st1, st0						; // x'
 419 | 	fst		dword [WRK+go4kVCO_wrk.cm]	
 420 | 	pop		eax
 421 | 	ret	
 422 | %endif
 423 | 
 424 | %ifdef USE_SECTIONS	
 425 | section		.g4kcodb	code	align=1
 426 | %else
 427 | section .text
 428 | %endif
 429 | export_func	go4kVCO_func@0
 430 | %ifdef GO4K_USE_VCO_PHASE_OFFSET
 431 | 	%ifdef GO4K_USE_VCO_SHAPE
 432 | 		%ifdef GO4K_USE_VCO_GATE
 433 | 			push 8
 434 | 		%else
 435 | 			push 7
 436 | 		%endif
 437 | 	%else
 438 | 		%ifdef GO4K_USE_VCO_GATE
 439 | 			push 7
 440 | 		%else
 441 | 			push 6
 442 | 		%endif
 443 | 	%endif
 444 | %else
 445 | 	%ifdef GO4K_USE_VCO_SHAPE
 446 | 		%ifdef GO4K_USE_VCO_GATE
 447 | 			push 7
 448 | 		%else
 449 | 			push 6
 450 | 		%endif
 451 | 	%else
 452 | 		%ifdef GO4K_USE_VCO_GATE
 453 | 			push 6
 454 | 		%else
 455 | 			push 5
 456 | 		%endif
 457 | 	%endif
 458 | %endif
 459 | 	call	go4kTransformValues
 460 | %ifdef GO4K_USE_VCO_CHECK
 461 | ; check if current note still active
 462 | 	mov		eax, dword [ecx-4]
 463 | 	test	eax, eax
 464 | 	jne		go4kVCO_func_do
 465 | 	fldz
 466 | 	ret
 467 | go4kVCO_func_do:	
 468 | %endif
 469 | 	movzx	eax, byte [VAL-1]			; // get flags
 470 | 	fld		dword [edx+go4kVCO_val.transpose]
 471 | 	fsub	dword [c_0_5]
 472 | %ifdef GO4K_USE_VCO_MOD_TM
 473 | 	fadd	dword [WRK+go4kVCO_wrk.tm]	
 474 | %endif
 475 | 	fdiv	dword [c_i128]
 476 | 	fld		dword [edx+go4kVCO_val.detune]
 477 | 	fsub	dword [c_0_5]
 478 | 	fadd	st0
 479 | 	faddp	st1
 480 | %ifdef GO4K_USE_VCO_MOD_DM	
 481 | 	fadd	dword [WRK+go4kVCO_wrk.dm]
 482 | %endif		
 483 | 	; // st0 now contains the transpose+detune offset
 484 | 	test	al, byte LFO
 485 | 	jnz		go4kVCO_func_skipnote
 486 | 	fiadd	dword [ecx-4]				; // st0 is note, st1 is t+d offset
 487 | go4kVCO_func_skipnote:		
 488 | 	fmul	dword [c_i12]
 489 | 	call	_Power@0
 490 | 	test	al, byte LFO
 491 | 	jz		short go4kVCO_func_normalize_note
 492 | 	fmul	dword [_LFO_NORMALIZE]	; // st0 is now frequency for lfo  
 493 | 	jmp		short go4kVCO_func_normalized
 494 | go4kVCO_func_normalize_note:	
 495 | 	fmul	dword [FREQ_NORMALIZE]	; // st0 is now frequency
 496 | go4kVCO_func_normalized:
 497 | 	fadd	dword [WRK+go4kVCO_wrk.phase]	
 498 | %ifdef GO4K_USE_VCO_MOD_FM	
 499 | 	fadd	dword [WRK+go4kVCO_wrk.fm]
 500 | %endif		
 501 | 	fld1
 502 | 	fadd	st1, st0
 503 | 	fxch	
 504 | 	fprem	
 505 | 	fstp	st1
 506 | 	fst		dword [WRK+go4kVCO_wrk.phase]
 507 | %ifdef GO4K_USE_VCO_MOD_PM	
 508 | 	fadd	dword [WRK+go4kVCO_wrk.pm]
 509 | %endif
 510 | %ifdef GO4K_USE_VCO_PHASE_OFFSET
 511 | 	fadd	dword [edx+go4kVCO_val.phaseofs]
 512 | %endif
 513 | %ifdef PHASE_RENORMALIZE	
 514 | 	fld1
 515 | 	fadd	st1, st0
 516 | 	fxch	
 517 | 	fprem	
 518 | 	fstp	st1											; // p
 519 | %endif	
 520 | 	fld		dword [edx+go4kVCO_val.color]				; // c		p
 521 | %ifdef GO4K_USE_VCO_MOD_CM	
 522 | 	fadd	dword [WRK+go4kVCO_wrk.cm]					; // c		p
 523 | %endif
 524 | go4kVCO_func_sine:	
 525 | 	test	al, byte SINE
 526 | 	jz		short go4kVCO_func_trisaw
 527 | 	call	go4kVCO_sine	
 528 | go4kVCO_func_trisaw:
 529 | 	test	al, byte TRISAW
 530 | 	jz		short go4kVCO_func_pulse	
 531 | 	call	go4kVCO_trisaw
 532 | go4kVCO_func_pulse:
 533 | 	test	al, byte PULSE
 534 | %ifdef GO4K_USE_VCO_GATE	
 535 | 	jz		short go4kVCO_func_gate
 536 | %else
 537 | 	jz		short go4kVCO_func_noise
 538 | %endif	
 539 | 	call	go4kVCO_pulse
 540 | %ifdef GO4K_USE_VCO_GATE	
 541 | go4kVCO_func_gate:
 542 | 	test	al, byte GATE
 543 | 	jz		short go4kVCO_func_noise
 544 | 	call	go4kVCO_gate
 545 | %endif		
 546 | go4kVCO_func_noise:	
 547 | 	test	al, byte NOISE
 548 | 	jz		short go4kVCO_func_end
 549 | 	call	_FloatRandomNumber@0
 550 | 	fstp	st1
 551 | 	fstp	st1
 552 | go4kVCO_func_end:
 553 | %ifdef GO4K_USE_VCO_SHAPE
 554 | 	fld		dword [edx+go4kVCO_val.shape]
 555 | %ifdef GO4K_USE_VCO_MOD_SM	
 556 | 	fadd	dword [WRK+go4kVCO_wrk.sm]
 557 | %endif
 558 | 	call	go4kWaveshaper	
 559 | %endif	
 560 | 	fld		dword [edx+go4kVCO_val.gain]
 561 | %ifdef GO4K_USE_VCO_MOD_GM	
 562 | 	fadd	dword [WRK+go4kVCO_wrk.gm]
 563 | %endif
 564 | 	fmulp	st1, st0	
 565 | 	ret
 566 | 
 567 | %ifdef USE_SECTIONS
 568 | section		.g4kcodc	code	align=1
 569 | %else
 570 | section .text
 571 | %endif	
 572 | ; //----------------------------------------------------------------------------------------
 573 | ; //	VCF Tick
 574 | ; //----------------------------------------------------------------------------------------
 575 | ; // IN		:		WRK	= unit workspace
 576 | ; // IN		:		VAL	= unit values
 577 | ; // IN		:		ecx	= global workspace
 578 | ; // OUT	:		
 579 | ; // DIRTY	:		eax
 580 | ; //----------------------------------------------------------------------------------------
 581 | export_func	go4kVCF_func@0
 582 | 	push	3
 583 | 	call	go4kTransformValues
 584 | %ifdef GO4K_USE_VCF_CHECK
 585 | ; check if current note still active
 586 | 	mov		eax, dword [ecx-4]
 587 | 	test	eax, eax
 588 | 	jne		go4kVCF_func_do
 589 | 	ret	
 590 | go4kVCF_func_do:
 591 | %endif
 592 | 	movzx	eax, byte [VAL-1]				; // get type flag 	
 593 | 	fld		dword [edx+go4kVCF_val.res]		; //	r		in
 594 | %ifdef GO4K_USE_VCF_MOD_RM	
 595 | 	fadd	dword [WRK+go4kVCF_wrk.rm]			
 596 | %endif	
 597 | 	fld		dword [edx+go4kVCF_val.freq]	; //	f		r		in
 598 | %ifdef GO4K_USE_VCF_MOD_FM	
 599 | 	fadd	dword [WRK+go4kVCF_wrk.fm]
 600 | %endif
 601 | 	fmul	st0, st0						; // square the input so we never get negative and also have a smoother behaviour in the lower frequencies
 602 | 	fst		dword [WRK+go4kVCF_wrk.freq]	; //	f		r		in
 603 | 	fmul	dword [WRK+go4kVCF_wrk.band]	; //	f*b		r		in
 604 | 	fadd	dword [WRK+go4kVCF_wrk.low]		; //    l'		r		in
 605 | 	fst		dword [WRK+go4kVCF_wrk.low]		; //    l'		r		in
 606 | 	fsubp	st2, st0						; //	r		in-l'
 607 | 	fmul	dword [WRK+go4kVCF_wrk.band]	; //	r*b		in-l'
 608 | 	fsubp	st1, st0						; // 	h'
 609 | 	fst		dword [WRK+go4kVCF_wrk.high]	; //    h'
 610 | 	fmul	dword [WRK+go4kVCF_wrk.freq]	; //    h'*f
 611 | 	fadd	dword [WRK+go4kVCF_wrk.band]	; //	b'
 612 | 	fstp	dword [WRK+go4kVCF_wrk.band]
 613 | 	fldz
 614 | go4kVCF_func_low:	
 615 | 	test	al, byte LOWPASS
 616 | 	jz		short go4kVCF_func_high
 617 | 	fadd	dword [WRK+go4kVCF_wrk.low]
 618 | go4kVCF_func_high:
 619 | %ifdef GO4K_USE_VCF_HIGH
 620 | 	test	al, byte HIGHPASS
 621 | 	jz		short go4kVCF_func_band
 622 | 	fadd	dword [WRK+go4kVCF_wrk.high]
 623 | %endif	
 624 | go4kVCF_func_band:
 625 | %ifdef GO4K_USE_VCF_BAND
 626 | 	test	al, byte BANDPASS
 627 | 	jz		short go4kVCF_func_peak
 628 | 	fadd	dword [WRK+go4kVCF_wrk.band]
 629 | %endif
 630 | go4kVCF_func_peak:
 631 | %ifdef GO4K_USE_VCF_PEAK
 632 | 	test	al, byte PEAK
 633 | 	jz		short go4kVCF_func_end
 634 | 	fadd	dword [WRK+go4kVCF_wrk.low]
 635 | 	fsub	dword [WRK+go4kVCF_wrk.high]
 636 | %endif
 637 | go4kVCF_func_end:							; // value	-		-		-		-
 638 | %ifdef GO4K_USE_UNDENORMALIZE
 639 | 	fadd	dword [c_0_5]				;   add and sub small offset to prevent denormalization
 640 | 	fsub	dword [c_0_5]
 641 | %endif
 642 | 	ret
 643 | 
 644 | %ifdef USE_SECTIONS
 645 | section		.g4kcodd	code	align=1
 646 | %else
 647 | section .text
 648 | %endif
 649 | ; //----------------------------------------------------------------------------------------
 650 | ; //	DST Tick
 651 | ; //----------------------------------------------------------------------------------------
 652 | ; // IN		:		WRK	= unit workspace
 653 | ; // IN		:		VAL	= unit values
 654 | ; // IN		:		ecx	= global workspace
 655 | ; // OUT	:		
 656 | ; // DIRTY	:		eax
 657 | ; //----------------------------------------------------------------------------------------
 658 | export_func	go4kDST_func@0
 659 | %ifdef GO4K_USE_DST
 660 | %ifdef GO4K_USE_DST_SH
 661 | 	push	2
 662 | %else	
 663 | 	push	1
 664 | %endif	
 665 | 	call	go4kTransformValues
 666 | %ifdef GO4K_USE_DST_CHECK
 667 | ; check if current note still active
 668 | 	mov		eax, dword [ecx-4]
 669 | 	test	eax, eax
 670 | 	jne		go4kDST_func_do
 671 | 	ret	
 672 | go4kDST_func_do:
 673 | %endif
 674 | %ifdef	GO4K_USE_DST_SH
 675 | 	fld		dword [edx+go4kDST_val.snhfreq]	; //	snh		in
 676 | %ifdef 	GO4K_USE_DST_MOD_SH	
 677 | 	fadd	dword [WRK+go4kDST_wrk.sm]		; // 	snh'	in
 678 | %endif
 679 | 	fmul	st0, st0						; // square the input so we never get negative and also have a smoother behaviour in the lower frequencies
 680 | 	fchs
 681 | 	fadd	dword [WRK+go4kDST_wrk.snhphase]; // 	snh'	in
 682 | 	fst		dword [WRK+go4kDST_wrk.snhphase]
 683 | 	fldz									; //	0		snh'	in
 684 | 	fucomip	st1								; //	0		snh'	in
 685 | 	jc		short go4kDST_func_hold			
 686 | 	fld1									; //	1		snh'	in
 687 | 	faddp	st1, st0						; //	1+snh'	in
 688 | 	fstp	dword [WRK+go4kDST_wrk.snhphase]; // 	in
 689 | %endif	
 690 | ; // calc pregain and postgain	
 691 | 	fld		dword [edx+go4kDST_val.drive]	; // 	drive		in
 692 | %ifdef GO4K_USE_DST_MOD_DM	
 693 | 	fadd	dword [WRK+go4kDST_wrk.dm]
 694 | %endif
 695 | 	call	go4kWaveshaper					; // out
 696 | %ifdef	GO4K_USE_DST_SH		
 697 | 	fst		dword [WRK+go4kDST_wrk.out]		; // out'
 698 | %endif	
 699 | 	ret										; // out'
 700 | %ifdef	GO4K_USE_DST_SH	
 701 | go4kDST_func_hold:	
 702 | 	fstp	st0								; // in
 703 | 	fstp	st0
 704 | 	fld		dword [WRK+go4kDST_wrk.out]		; // out
 705 | 	ret
 706 | %endif	
 707 | 
 708 | %endif
 709 | 
 710 | %ifdef USE_SECTIONS	
 711 | section		.g4kcodf	code	align=1
 712 | %else
 713 | section .text
 714 | %endif
 715 | ; //----------------------------------------------------------------------------------------
 716 | ; //	DLL Tick
 717 | ; //----------------------------------------------------------------------------------------
 718 | ; // IN		:		WRK	= unit workspace
 719 | ; // IN		:		VAL	= unit values
 720 | ; // IN		:		ecx	= global workspace
 721 | ; // OUT	:		
 722 | ; // DIRTY	:		eax
 723 | ; //----------------------------------------------------------------------------------------
 724 | export_func	go4kDLL_func@0
 725 | %ifdef GO4K_USE_DLL
 726 | %ifdef GO4K_USE_DLL_CHORUS
 727 | 	%ifdef GO4K_USE_DLL_DAMP
 728 | 		push	8
 729 | 	%else
 730 | 		push	7
 731 | 	%endif		
 732 | %else
 733 | 	%ifdef GO4K_USE_DLL_DAMP
 734 | 		push	6
 735 | 	%else
 736 | 		push	5
 737 | 	%endif		
 738 | %endif	
 739 | 	call	go4kTransformValues
 740 | 	pushad
 741 | 	movzx	ebx, byte [VAL-(go4kDLL_val.size-go4kDLL_val.delay)/4]	;// delay length index
 742 | %ifdef GO4K_USE_DLL_NOTE_SYNC
 743 | 	test	ebx, ebx
 744 | 	jne		go4kDLL_func_process
 745 | 	fld1
 746 | 	fild	dword [ecx-4]			; // load note freq
 747 | 	fmul	dword [c_i12]
 748 | 	call	_Power@0
 749 | 	fmul	dword [FREQ_NORMALIZE]	; // normalize
 750 | 	fdivp	st1, st0				; // invert to get numer of samples
 751 | 	fistp	word [_go4k_delay_times+ebx*2]	; store current comb size
 752 | %endif	
 753 | go4kDLL_func_process:
 754 | 	mov		ecx, eax							;// ecx is delay counter	
 755 | %ifdef 	GO4K_USE_DLL_MOD
 756 | 	mov		edi, WRK							;// edi is modulation workspace
 757 | %endif
 758 | 	mov		WRK, dword [_go4k_delay_buffer_ofs]	;// ebp is current delay
 759 | 	fld		st0									;// in		in
 760 | %ifdef GO4K_USE_DLL_MOD_IM
 761 | 	fld		dword [edx+go4kDLL_val.dry]			;// dry		in		in
 762 | 	fadd	dword [edi+go4kDLL_wrk2.im]			;// dry'	in		in
 763 | 	fmulp	st1, st0							;// out		in
 764 | %else	
 765 | 	fmul	dword [edx+go4kDLL_val.dry]			;// out		in
 766 | %endif	
 767 | 	fxch										;// in		out
 768 | %ifdef GO4K_USE_DLL_MOD_PM
 769 | 	fld		dword [edx+go4kDLL_val.pregain]		;// pg		in		out
 770 | 	fadd	dword [edi+go4kDLL_wrk2.pm]			;// pg'		in		out
 771 | 	fmul	st0, st0							;// pg''	in		out
 772 | 	fmulp	st1, st0							;// in'		out
 773 | %else	
 774 | 	fmul	dword [edx+go4kDLL_val.pregain]		;// in'		out
 775 | 	fmul	dword [edx+go4kDLL_val.pregain]		;// in'		out
 776 | %endif	
 777 | 
 778 | %ifdef GO4K_USE_DLL_CHORUS	
 779 | ;// update saw lfo for chorus/flanger
 780 | 	fld		dword [edx+go4kDLL_val.freq]		;// f		in'		out
 781 | %ifdef GO4K_USE_DLL_MOD_SM
 782 | 	fadd	dword [edi+go4kDLL_wrk2.sm]			;// f'		in'		out
 783 | %endif	
 784 | 	fmul	st0, st0
 785 | 	fmul	st0, st0
 786 | 	fdiv	dword [DLL_DEPTH]
 787 | 	fadd	dword [WRK+go4kDLL_wrk.phase]		;// p'		in'		out
 788 | ;// clamp phase to 0,1 (only in editor, since delay can be active quite long)
 789 | %ifdef GO4K_USE_DLL_CHORUS_CLAMP
 790 | 	fld1										;// 1		p'		in'		out
 791 | 	fadd	st1, st0							;// 1		1+p'	in'		out
 792 | 	fxch										;// 1+p'	1		in'		out
 793 | 	fprem										;// p''		1		in'		out
 794 | 	fstp	st1									;// p''		in'		out
 795 | %endif
 796 | 	fst		dword [WRK+go4kDLL_wrk.phase]
 797 | ;// get current sine value
 798 | 	fldpi										; // pi		p		in'		out
 799 | 	fadd	st0									; // 2*pi	p		in'		out
 800 | 	fmulp	st1, st0							; // 2*pi*p	in'		out
 801 | 	fsin										; // sin	in'		out	
 802 | 	fld1										; // 1		sin		in'		out	
 803 | 	faddp	st1, st0							; // 1+sin	in'		out		
 804 | ;// mul with depth and convert to samples	
 805 | 	fld		dword [edx+go4kDLL_val.depth]		; // d		1+sin	in'		out
 806 | %ifdef GO4K_USE_DLL_MOD_AM
 807 | 	fadd	dword [edi+go4kDLL_wrk2.am]			; // d'		1+sin	in'		out
 808 | %endif	
 809 | 	fmul	st0, st0
 810 | 	fmul	st0, st0
 811 | 	fmul	dword [DLL_DEPTH]
 812 | 	fmulp	st1, st0
 813 | 	fistp   dword [esp-4]						; // in'	out	
 814 | %endif	
 815 | 	
 816 | go4kDLL_func_loop:
 817 | 	movzx	esi, word [_go4k_delay_times+ebx*2]	; fetch comb size
 818 | 	mov 	eax, dword [WRK+go4kDLL_wrk.index]	;// eax is current comb index
 819 | 
 820 | %ifdef GO4K_USE_DLL_CHORUS	
 821 | 	;// add lfo offset and wrap buffer
 822 | 	add		eax, dword [esp-4]
 823 | 	cmp		eax, esi
 824 | 	jl		short go4kDLL_func_buffer_nowrap1
 825 | 	sub		eax, esi
 826 | go4kDLL_func_buffer_nowrap1:		
 827 | %endif
 828 | 		
 829 | 	fld		dword [WRK+eax*4+go4kDLL_wrk.buffer];//	cout		in'			out		
 830 | 
 831 | %ifdef GO4K_USE_DLL_CHORUS	
 832 | 	mov 	eax, dword [WRK+go4kDLL_wrk.index]
 833 | %endif	
 834 | 	
 835 | 	;// add comb output to current output
 836 | 	fadd	st2, st0							;//	cout		in'			out'
 837 | %ifdef GO4K_USE_DLL_DAMP
 838 | 	fld1										;//	1			cout		in'			out'		
 839 | 	fsub 	dword [edx+go4kDLL_val.damp]		;//	1-damp		cout		in'			out'
 840 | %ifdef GO4K_USE_DLL_MOD_DM
 841 | 	fsub	dword [edi+go4kDLL_wrk2.dm]			;//	1-damp'		cout		in'			out'
 842 | %endif	
 843 | 	fmulp	st1, st0							;//	cout*d2		in'			out'		
 844 | 	fld		dword [edx+go4kDLL_val.damp]		;//	d1   		cout*d2		in'			out'
 845 | %ifdef GO4K_USE_DLL_MOD_DM
 846 | 	fadd	dword [edi+go4kDLL_wrk2.dm]			;//	d1'   		cout*d2		in'			out'
 847 | %endif	
 848 | 	fmul	dword [WRK+go4kDLL_wrk.store]		;//	store*d1	cout*d2		in'			out'		
 849 | 	faddp	st1, st0							;//	store'		in'			out'	
 850 | 	fst		dword [WRK+go4kDLL_wrk.store]		;//	store'		in'			out'		
 851 | %endif	
 852 | %ifdef GO4K_USE_DLL_MOD_FM
 853 | 	fld		dword [edx+go4kDLL_val.feedback]	;//	fb			cout		in'			out'
 854 | 	fadd 	dword [edi+go4kDLL_wrk2.fm]			;//	fb'			cout		in'			out'
 855 | 	fmulp	st1, st0							;//	cout*fb'	in'			out'
 856 | %else
 857 | 	fmul	dword [edx+go4kDLL_val.feedback]	;//	cout*fb		in'			out'
 858 | %endif	
 859 | %ifdef GO4K_USE_DLL_DC_FILTER		
 860 | 	fadd	st0, st1							;//	store		in'			out'
 861 | 	fstp	dword [WRK+eax*4+go4kDLL_wrk.buffer];//	in'			out'
 862 | %else	
 863 | 	fsub	st0, st1							;//	store		in'			out'	
 864 | 	fstp	dword [WRK+eax*4+go4kDLL_wrk.buffer];//	in'			out'
 865 | 	fneg		
 866 | %endif
 867 | 	;// wrap comb buffer pos
 868 | 	inc 	eax
 869 | 	cmp		eax, esi
 870 | 	jl		short go4kDLL_func_buffer_nowrap2
 871 | %ifdef GO4K_USE_DLL_CHORUS	
 872 | 	sub		eax, esi
 873 | %else
 874 | 	xor		eax, eax
 875 | %endif	
 876 | go4kDLL_func_buffer_nowrap2:	
 877 | 	mov 	dword [WRK+go4kDLL_wrk.index], eax		
 878 | 	;// increment buffer pointer to next buffer
 879 | 	inc		ebx									;// go to next delay length index
 880 | 	add		WRK, go4kDLL_wrk.size				;// go to next delay
 881 | 	mov		dword [_go4k_delay_buffer_ofs], WRK	;// store next delay offset
 882 | 	loopne	go4kDLL_func_loop	
 883 | 	fstp	st0									;//	out'
 884 | 	;// process a dc filter to prevent heavy offsets in reverb
 885 | 	;// we're using the dc filter variables from the next delay line here, but doesnt hurt anyway				
 886 | %ifdef GO4K_USE_DLL_DC_FILTER
 887 | ; 	y(n) = x(n) - x(n-1) + R * y(n-1) 
 888 | 	fld		dword [WRK+go4kDLL_wrk.dcout]		;//	dco			out'
 889 | 	fmul	dword [c_dc_const]					;//	dcc*dco		out'
 890 | 	fsub	dword [WRK+go4kDLL_wrk.dcin]		;//	dcc*dco-dci	out'
 891 | 	fxch										;//	out'		dcc*dco-dci
 892 | 	fst		dword [WRK+go4kDLL_wrk.dcin]		;//	out'		dcc*dco-dci
 893 | 	faddp	st1									;//	out'
 894 | %ifdef GO4K_USE_UNDENORMALIZE
 895 | 	fadd	dword [c_0_5]						;// add and sub small offset to prevent denormalization
 896 | 	fsub	dword [c_0_5]
 897 | %endif	
 898 | 	fst		dword [WRK+go4kDLL_wrk.dcout]
 899 | %endif
 900 | 	popad
 901 | 	ret
 902 | %endif
 903 | 
 904 | %ifdef USE_SECTIONS
 905 | section		.g4kcodg	code	align=1
 906 | %else
 907 | section .text
 908 | %endif
 909 | ; //----------------------------------------------------------------------------------------
 910 | ; //	FOP Tick (various fp stack based operations)
 911 | ; //----------------------------------------------------------------------------------------
 912 | ; // IN		:		WRK	= unit workspace
 913 | ; // IN		:		VAL	= unit values
 914 | ; // IN		:		ecx	= global workspace
 915 | ; // OUT	:		
 916 | ; // DIRTY	:		
 917 | ; //----------------------------------------------------------------------------------------
 918 | export_func	go4kFOP_func@0
 919 | 	push	1
 920 | 	call	go4kTransformValues
 921 | go4kFOP_func_pop:	
 922 | 	dec		eax
 923 | 	jnz		go4kFOP_func_addp	
 924 | 	fstp	st0
 925 | 	ret
 926 | go4kFOP_func_addp:		
 927 | 	dec		eax
 928 | 	jnz		go4kFOP_func_mulp
 929 | 	faddp	st1, st0
 930 | 	ret
 931 | go4kFOP_func_mulp:		
 932 | 	dec		eax
 933 | 	jnz		go4kFOP_func_push
 934 | 	fmulp	st1, st0
 935 | 	ret		
 936 | go4kFOP_func_push:
 937 | 	dec		eax
 938 | 	jnz		go4kFOP_func_xch
 939 | 	fld		st0
 940 | 	ret
 941 | go4kFOP_func_xch:		
 942 | 	dec		eax
 943 | 	jnz		go4kFOP_func_add
 944 | 	fxch
 945 | 	ret	
 946 | go4kFOP_func_add:		
 947 | 	dec		eax
 948 | 	jnz		go4kFOP_func_mul
 949 | 	fadd	st1
 950 | 	ret
 951 | go4kFOP_func_mul:		
 952 | 	dec		eax
 953 | 	jnz		go4kFOP_func_addp2
 954 | 	fmul	st1
 955 | 	ret
 956 | %ifdef GO4K_USE_FOP_LOADNOTE
 957 | go4kFOP_func_addp2:
 958 | 	dec		eax
 959 | 	jnz		go4kFOP_func_loadnote
 960 | 	faddp	st2, st0
 961 | 	faddp	st2, st0
 962 | 	ret
 963 | go4kFOP_func_loadnote:					
 964 | 	fild	dword [ecx-4]
 965 | 	fmul	dword [c_i128]
 966 | 	ret
 967 | %else
 968 | go4kFOP_func_addp2:
 969 | 	dec		eax
 970 | 	jnz		go4kFOP_func_dummy+1			; // now this is no valid jump address (just to please the packer) but if we run in that case we're fucked up anyway
 971 | 	faddp	st2, st0
 972 | go4kFOP_func_dummy:					
 973 | 	faddp	st2, st0
 974 | 	ret	
 975 | %endif	
 976 | 	
 977 | %ifdef USE_SECTIONS	
 978 | section		.g4kcodh	code	align=1
 979 | %else
 980 | section .text
 981 | %endif
 982 | ; //----------------------------------------------------------------------------------------
 983 | ; //	FST Tick (stores a value somewhere in the local workspace)
 984 | ; //----------------------------------------------------------------------------------------
 985 | ; // IN		:		WRK	= unit workspace
 986 | ; // IN		:		VAL	= unit values
 987 | ; // IN		:		ecx	= global workspace
 988 | ; // OUT	:		
 989 | ; // DIRTY	:		
 990 | ; //----------------------------------------------------------------------------------------
 991 | export_func	go4kFST_func@0
 992 | 	push	2
 993 | 	call	go4kTransformValues
 994 | 	fld		dword [edx+go4kFST_val.amount]
 995 | 	fsub	dword [c_0_5]
 996 | 	fadd	st0
 997 | 	fmul	st1
 998 | 	fstp	dword [ecx+eax*4]						; // eax already contains the destination from the go4kTransformValues call
 999 | 	ret
1000 | 
1001 | %ifdef USE_SECTIONS	
1002 | section		.g4kcodm	code	align=1
1003 | %else
1004 | section .text
1005 | %endif
1006 | ; //----------------------------------------------------------------------------------------
1007 | ; //	FLD Tick (load a value on stack, optionally add a modulation signal beforehand)
1008 | ; //----------------------------------------------------------------------------------------
1009 | ; // IN		:		WRK	= unit workspace
1010 | ; // IN		:		VAL	= unit values
1011 | ; // IN		:		ecx	= global workspace
1012 | ; // OUT	:		signal-signal*pan , signal*pan
1013 | ; // DIRTY	:		
1014 | ; //----------------------------------------------------------------------------------------	
1015 | export_func	go4kFLD_func@0								;// in		main env
1016 | %ifdef GO4K_USE_FLD
1017 | 	push	1
1018 | 	call	go4kTransformValues
1019 | 	fld		dword [edx+go4kFLD_val.value]				;// value		in
1020 | 	fsub	dword [c_0_5]
1021 | 	fadd	st0
1022 | %ifdef GO4K_USE_FLD_MOD_VM
1023 | 	fadd	dword [WRK+go4kFLD_wrk.vm]					;// value'		in
1024 | %endif
1025 | %endif	
1026 | 	ret		
1027 | 	
1028 | %ifdef GO4K_USE_FSTG
1029 | %ifdef USE_SECTIONS	
1030 | section		.g4kcodi	code	align=1
1031 | %else
1032 | section .text
1033 | %endif	
1034 | ; //----------------------------------------------------------------------------------------
1035 | ; //	FSTG Tick (stores a value anywhere in the synth (and in each voice))
1036 | ; //----------------------------------------------------------------------------------------
1037 | ; // IN		:		WRK	= unit workspace
1038 | ; // IN		:		VAL	= unit values
1039 | ; // IN		:		ecx	= global workspace
1040 | ; // OUT	:		
1041 | ; // DIRTY	:		
1042 | ; //----------------------------------------------------------------------------------------
1043 | export_func	go4kFSTG_func@0
1044 | 	push	5
1045 | 	call	go4kTransformValues
1046 | %ifdef GO4K_USE_FSTG_CHECK
1047 | ; check if current note still active
1048 | 	mov		eax, dword [ecx-4]
1049 | 	test	eax, eax
1050 | 	jne		go4kFSTG_func_do
1051 | 	ret
1052 | go4kFSTG_func_do:	
1053 | %endif
1054 | 	fld		dword [edx+go4kFST_val.amount]
1055 | 	fsub	dword [c_0_5]
1056 | 	fadd	st0
1057 | 	fmul	st1
1058 | 	mov		eax, dword [VAL-4]
1059 | %if MAX_VOICES > 1	
1060 | 	fst		dword [go4k_synth_wrk+eax]
1061 | 	fstp	dword [go4k_synth_wrk+eax+go4k_instrument.size]
1062 | %else
1063 | 	fstp	dword [go4k_synth_wrk+eax]	
1064 | %endif	
1065 | 	
1066 | 	ret	
1067 | 
1068 | %endif	
1069 | 
1070 | %ifdef USE_SECTIONS	
1071 | section		.g4kcodj	code	align=1
1072 | %else
1073 | section .text
1074 | %endif
1075 | ; //----------------------------------------------------------------------------------------
1076 | ; //	PAN Tick (multiplies signal with main envelope and converts to stereo)
1077 | ; //----------------------------------------------------------------------------------------
1078 | ; // IN		:		WRK	= unit workspace
1079 | ; // IN		:		VAL	= unit values
1080 | ; // IN		:		ecx	= global workspace
1081 | ; // OUT	:		signal-signal*pan , signal*pan
1082 | ; // DIRTY	:		
1083 | ; //----------------------------------------------------------------------------------------	
1084 | export_func	go4kPAN_func@0								;// in		main env
1085 | %ifdef GO4K_USE_PAN
1086 | 	push	1
1087 | 	call	go4kTransformValues
1088 | 	fld		dword [edx+go4kPAN_val.panning]				;// pan		in
1089 | %ifdef GO4K_USE_PAN_MOD	
1090 | 	fadd	dword [WRK+go4kPAN_wrk.pm]					;// pan		in
1091 | %endif
1092 | 	fmul	st1											;// r		in
1093 | 	fsub	st1, st0									;// r		l
1094 | 	fxch												;// l		r
1095 | %else
1096 | 	fmul	dword [c_0_5]
1097 | 	fld		st0
1098 | %endif	
1099 | 	ret
1100 | 
1101 | %ifdef USE_SECTIONS	
1102 | section		.g4kcodk	code	align=1
1103 | %else
1104 | section .text
1105 | %endif	
1106 | ; //----------------------------------------------------------------------------------------
1107 | ; //	OUT Tick ( stores stereo signal pair in temp buffers of the instrument)
1108 | ; //----------------------------------------------------------------------------------------
1109 | ; // IN		:		WRK	= unit workspace
1110 | ; // IN		:		VAL	= unit values
1111 | ; // IN		:		ecx	= global workspace
1112 | ; // OUT	:		
1113 | ; // DIRTY	:		
1114 | ; //----------------------------------------------------------------------------------------
1115 | export_func	go4kOUT_func@0								;// l		r
1116 | %ifdef	GO4K_USE_GLOBAL_DLL
1117 | 	push	2
1118 | 	call	go4kTransformValues
1119 | 	pushad
1120 | 	lea		edi, [ecx+256*4]
1121 | 	fld		st1											;//	r		l		r
1122 | 	fld		st1											;// l		r		l		r
1123 | 	fld		dword [edx+go4kOUT_val.auxsend]				;// as		l		r		l		r
1124 | %ifdef 	GO4K_USE_OUT_MOD_AM
1125 | 	fadd	dword [WRK+go4kOUT_wrk.am]					;//	am		l		r		l		r
1126 | %endif	
1127 | 	fmulp	st1, st0									;//	l'		r		l		r
1128 | 	fstp	dword [edi]									;// r		l		r
1129 | 	scasd
1130 | 	fld		dword [edx+go4kOUT_val.auxsend]				;// as		r		l		r
1131 | %ifdef 	GO4K_USE_OUT_MOD_AM
1132 | 	fadd	dword [WRK+go4kOUT_wrk.am]					;//	am		r		l		r
1133 | %endif	
1134 | 	fmulp	st1, st0									;//	r'		l		r
1135 | 	fstp	dword [edi]									;// l		r
1136 | 	scasd
1137 | 	fld		dword [edx+go4kOUT_val.gain]				;// g		l		r
1138 | %ifdef 	GO4K_USE_OUT_MOD_GM
1139 | 	fadd	dword [WRK+go4kOUT_wrk.gm]					;//	gm		l		r
1140 | %endif	
1141 | 	fmulp	st1, st0									;//	l'		r
1142 | 	fstp	dword [edi]									;// r
1143 | 	scasd
1144 | 	fld		dword [edx+go4kOUT_val.gain]				;// g		r
1145 | %ifdef 	GO4K_USE_OUT_MOD_GM
1146 | 	fadd	dword [WRK+go4kOUT_wrk.gm]					;//	gm		r
1147 | %endif	
1148 | 	fmulp	st1, st0									;//	r'
1149 | 	fstp	dword [edi]									;// -
1150 | 	scasd
1151 | 	popad
1152 | %else
1153 | 	push	1
1154 | 	call	go4kTransformValues
1155 | 
1156 | 	fld		dword [edx+go4kOUT_val.gain]				;// g		l		r
1157 | %ifdef 	GO4K_USE_OUT_MOD_GM
1158 | 	fadd	dword [WRK+go4kOUT_wrk.gm]					;//	gm		l		r
1159 | %endif	
1160 | 	fmulp	st1, st0									;//	l'		r
1161 | 	fstp	dword [ecx+256*4+0]							;// r
1162 | 	fld		dword [edx+go4kOUT_val.gain]				;// g		r
1163 | %ifdef 	GO4K_USE_OUT_MOD_GM
1164 | 	fadd	dword [WRK+go4kOUT_wrk.gm]					;//	gm		r
1165 | %endif	
1166 | 	fmulp	st1, st0									;//	r'
1167 | 	fstp	dword [ecx+256*4+4]							;// -
1168 | 	
1169 | %endif		
1170 | 	ret	
1171 | 
1172 | %ifdef USE_SECTIONS	
1173 | section		.g4kcodl	code	align=1
1174 | %else
1175 | section .text
1176 | %endif
1177 | ; //----------------------------------------------------------------------------------------
1178 | ; //	ACC Tick (stereo signal accumulation for synth commands only -> dont use in instrument commands)
1179 | ; //----------------------------------------------------------------------------------------
1180 | ; // IN		:		WRK	= unit workspace
1181 | ; // IN		:		VAL	= unit values
1182 | ; // IN		:		ecx	= global workspace
1183 | ; // OUT	:		
1184 | ; // DIRTY	:		eax
1185 | ; //----------------------------------------------------------------------------------------
1186 | export_func	go4kACC_func@0
1187 | 	push	1
1188 | 	call	go4kTransformValues
1189 | 	pushad
1190 | 	mov		edi, go4k_synth_wrk
1191 | 	add		edi, go4k_instrument.size
1192 | 	sub		edi, eax					; // eax already contains the accumulation offset from the go4kTransformValues call
1193 | 	mov		cl, MAX_INSTRUMENTS*MAX_VOICES
1194 | 	fldz								;// 0
1195 | 	fldz								;//	0		0
1196 | go4kACC_func_loop:	
1197 | 	fadd	dword [edi-8]				;// l		0
1198 | 	fxch								;// 0		l
1199 | 	fadd	dword [edi-4]				;// r		l
1200 | 	fxch								;// l		r
1201 | 	add		edi, go4k_instrument.size
1202 | 	dec		cl
1203 | 	jnz		go4kACC_func_loop
1204 | 	popad
1205 | 	ret
1206 | 	
1207 | %ifdef USE_SECTIONS
1208 | section		.g4kcodw	code	align=1
1209 | %else
1210 | section .text
1211 | %endif
1212 | ; //----------------------------------------------------------------------------------------
1213 | ; //	Update Instrument (allocate voices, set voice to release)
1214 | ; //----------------------------------------------------------------------------------------
1215 | ; // IN		:		
1216 | ; // IN		:		
1217 | ; // OUT	:		
1218 | ; // DIRTY	:		
1219 | ; //----------------------------------------------------------------------------------------
1220 | go4kUpdateInstrument:
1221 | ; // get new note
1222 | 	mov		eax, dword [esp+4+4]					; // eax = current tick
1223 | 	shr		eax, PATTERN_SIZE_SHIFT					; // eax = current pattern
1224 | 	imul	edx, ecx, dword MAX_PATTERNS				; // edx = instrument pattern list index
1225 | 	movzx	edx, byte [edx+eax+go4k_pattern_lists]	; // edx = pattern index
1226 | 	mov		eax, dword [esp+4+4]					; // eax = current tick
1227 | 	shl		edx, PATTERN_SIZE_SHIFT					
1228 | 	and		eax, PATTERN_SIZE-1
1229 | 	movzx	edx, byte [edx+eax+go4k_patterns]	; // edx = requested note in new patterntick
1230 | ; // apply note changes
1231 | 	cmp		dl, HLD									; // anything but hold causes action
1232 | 	je		short go4kUpdateInstrument_done
1233 | 	inc		dword [edi]								; // set release flag if needed
1234 | %if MAX_VOICES > 1	
1235 | 	inc		dword [edi+go4k_instrument.size]		; // set release flag if needed
1236 | %endif	
1237 | 	cmp		dl, HLD									; // check for new note
1238 | 	jl		short go4kUpdateInstrument_done
1239 | %if MAX_VOICES > 1
1240 | 	pushad
1241 | 	xchg	eax, dword [go4k_voiceindex + ecx*4]
1242 | 	test	eax, eax
1243 | 	je		go4kUpdateInstrument_newNote
1244 | 	add		edi, go4k_instrument.size
1245 | go4kUpdateInstrument_newNote:
1246 | 	xor		al,1
1247 | 	xchg	dword [go4k_voiceindex + ecx*4], eax
1248 | %endif	
1249 | 	pushad
1250 | 	xor		eax, eax
1251 | 	mov		ecx, (8+256*4)/4						; // clear only relase, note and workspace
1252 | 	rep		stosd
1253 | 	popad
1254 | 	mov		dword [edi+4], edx						; // set requested note as current note
1255 | %if MAX_VOICES > 1	
1256 | 	popad
1257 | %endif
1258 | 	jmp		short go4kUpdateInstrument_done
1259 | go4kUpdateInstrument_done:
1260 | 	ret
1261 | 
1262 | %ifdef USE_SECTIONS
1263 | section		.g4kcodx	code	align=1
1264 | %else
1265 | section .text
1266 | %endif
1267 | ; //----------------------------------------------------------------------------------------
1268 | ; //	Render Voices
1269 | ; //----------------------------------------------------------------------------------------
1270 | ; // IN		:		
1271 | ; // IN		:		
1272 | ; // OUT	:		
1273 | ; // DIRTY	:		
1274 | ; //----------------------------------------------------------------------------------------
1275 | go4kRenderVoices:
1276 | 	push	ecx								; // save current instrument counter
1277 | %if MAX_VOICES > 1	
1278 | 	push	COM								; // save current instrument command index
1279 | 	push	VAL								; // save current instrument values index
1280 | %endif	
1281 | 	call	go4k_VM_process					; //  call synth vm for instrument voices
1282 | 	mov 	eax, dword [ecx+go4kENV_wrk.state]
1283 | 	cmp		al, byte ENV_STATE_OFF
1284 | 	jne		go4kRenderVoices_next
1285 | 	xor		eax, eax
1286 | 	mov		dword [ecx-4], eax				; // kill note if voice is done
1287 | go4kRenderVoices_next:
1288 | %if MAX_VOICES > 1			
1289 | 	pop		VAL								; // restore instrument value index
1290 | 	pop		COM								; // restore instrument command index
1291 | %endif
1292 | 
1293 | %ifdef GO4K_USE_BUFFER_RECORDINGS
1294 | 	mov		eax, dword [esp+16]				; // get current tick
1295 | 	shr		eax, 8							; // every 256th sample = ~ 172 hz
1296 | 	shl		eax, 5							; // for 16 instruments a 2 voices
1297 | 	add		eax, dword [esp]				
1298 | 	add		eax, dword [esp]				; // + 2*currentinstrument+0
1299 | %ifdef GO4K_USE_ENVELOPE_RECORDINGS
1300 | 	mov		edx, dword [ecx+go4kENV_wrk.level]
1301 | 	mov		dword [__4klang_envelope_buffer+eax*4], edx
1302 | %endif	
1303 | %ifdef GO4K_USE_NOTE_RECORDINGS
1304 | 	mov		edx, dword [ecx-4]
1305 | 	mov		dword [__4klang_note_buffer+eax*4], edx
1306 | %endif		
1307 | %endif
1308 | 
1309 | %if MAX_VOICES > 1			
1310 | 	call	go4k_VM_process					; //  call synth vm for instrument voices
1311 | 	mov 	eax, dword [ecx+go4kENV_wrk.state]
1312 | 	cmp		al, byte ENV_STATE_OFF
1313 | 	jne		go4k_render_instrument_next2
1314 | 	xor		eax, eax
1315 | 	mov		dword [ecx-4], eax				; // kill note if voice is done
1316 | go4k_render_instrument_next2:
1317 | 
1318 | %ifdef GO4K_USE_BUFFER_RECORDINGS
1319 | 	mov		eax, dword [esp+16]				; // get current tick
1320 | 	shr		eax, 8							; // every 256th sample = ~ 172 hz
1321 | 	shl		eax, 5							; // for 16 instruments a 2 voices
1322 | 	add		eax, dword [esp]				
1323 | 	add		eax, dword [esp]				; // + 2*currentinstrument+0
1324 | %ifdef GO4K_USE_ENVELOPE_RECORDINGS
1325 | 	mov		edx, dword [ecx+go4kENV_wrk.level]
1326 | 	mov		dword [__4klang_envelope_buffer+eax*4+4], edx
1327 | %endif	
1328 | %ifdef GO4K_USE_NOTE_RECORDINGS
1329 | 	mov		edx, dword [ecx-4]
1330 | 	mov		dword [__4klang_note_buffer+eax*4+4], edx
1331 | %endif		
1332 | %endif
1333 | 
1334 | %endif		
1335 | 	pop		ecx								; // restore instrument counter	
1336 | 	ret
1337 | 
1338 | %ifdef USE_SECTIONS				
1339 | section		.g4kcody	code	align=1
1340 | %else
1341 | section .text
1342 | %endif
1343 | ; //----------------------------------------------------------------------------------------
1344 | ; //	the entry point for the synth
1345 | ; //----------------------------------------------------------------------------------------
1346 | %ifdef USE_SECTIONS
1347 | export_func	_4klang_render@4
1348 | %else
1349 | export_func	_4klang_render
1350 | %endif
1351 | 	pushad
1352 | 	xor		ecx, ecx
1353 | %ifdef GO4K_USE_BUFFER_RECORDINGS		
1354 | 	push	ecx
1355 | %endif	
1356 | ; loop all ticks	
1357 | go4k_render_tickloop:	
1358 | 	push	ecx
1359 | 	xor		ecx, ecx
1360 | ; loop all samples per tick	
1361 | go4k_render_sampleloop:	
1362 | 		push	ecx
1363 | 		xor		ecx, ecx
1364 | 		mov		ebx, go4k_synth_instructions	; // ebx = instrument command index
1365 | 		mov		VAL, go4k_synth_parameter_values; // VAL = instrument values index
1366 | 		mov		edi, _go4k_delay_buffer			; // get offset of first delay buffer
1367 | 		mov		dword [_go4k_delay_buffer_ofs], edi	; // store offset in delaybuffer offset variable
1368 | 		mov		edi, go4k_synth_wrk				; // edi = first instrument
1369 | ; loop all instruments		
1370 | go4k_render_instrumentloop:	
1371 | 			mov		eax, dword [esp]				; // eax = current tick sample
1372 | 			and		eax, eax
1373 | 			jnz		go4k_render_instrument_process	; // tick change? (first sample in current tick)	
1374 | 			call	go4kUpdateInstrument			; // update instrument state
1375 | ; process instrument			
1376 | go4k_render_instrument_process:
1377 | 			call	go4kRenderVoices			
1378 | 			inc		ecx
1379 | 			cmp		cl, byte MAX_INSTRUMENTS
1380 | 			jl		go4k_render_instrumentloop
1381 | 		mov		dword [edi+4], ecx		; // move a value != 0 into note slot, so processing will be done
1382 | 		call	go4k_VM_process			; //  call synth vm for synth
1383 | go4k_render_output_sample:
1384 | %ifdef GO4K_USE_BUFFER_RECORDINGS	
1385 | 		inc		dword [esp+8]
1386 | 		xchg	esi, dword [esp+48]		; // edx = destbuffer
1387 | %else
1388 | 		xchg	esi, dword [esp+44]		; // edx = destbuffer
1389 | %endif
1390 | %ifdef 	GO4K_CLIP_OUTPUT
1391 | 		fld		dword [edi-8]
1392 | 		fld1									; //	1		val
1393 | 		fucomi	st1								; //	1		val
1394 | 		jbe		short go4k_render_clip1
1395 | 		fchs									; //	-1		val
1396 | 		fucomi	st1								; //	-1		val
1397 | 		fcmovb	st0, st1						; //	val		-1		(if val > -1)
1398 | go4k_render_clip1:
1399 | 		fstp	st1								; //	newval
1400 | %ifdef GO4K_USE_16BIT_OUTPUT		
1401 | 		push	eax
1402 | 		fmul	dword [c_32767]
1403 | 		fistp	dword [esp]
1404 | 		pop		eax
1405 | 		mov		word [esi],ax	; // store integer converted left sample
1406 | 		lodsw
1407 | %else
1408 | 		fstp	dword [esi]		; // store left sample
1409 | 		lodsd
1410 | %endif		
1411 | 		fld		dword [edi-4]
1412 | 		fld1									; //	1		val
1413 | 		fucomi	st1								; //	1		val
1414 | 		jbe		short go4k_render_clip2
1415 | 		fchs									; //	-1		val
1416 | 		fucomi	st1								; //	-1		val
1417 | 		fcmovb	st0, st1						; //	val		-1		(if val > -1)
1418 | go4k_render_clip2:
1419 | 		fstp	st1								; //	newval
1420 | %ifdef GO4K_USE_16BIT_OUTPUT		
1421 | 		push	eax
1422 | 		fmul	dword [c_32767]
1423 | 		fistp	dword [esp]
1424 | 		pop		eax
1425 | 		mov		word [esi],ax	; // store integer converted right sample
1426 | 		lodsw
1427 | %else
1428 | 		fstp	dword [esi]		; // store right sample
1429 | 		lodsd
1430 | %endif		
1431 | %else
1432 | 		fld		dword [edi-8]
1433 | %ifdef GO4K_USE_16BIT_OUTPUT
1434 | 		push	eax
1435 | 		fmul	dword [c_32767]
1436 | 		fistp	dword [esp]
1437 | 		pop		eax
1438 | 		mov		word [esi],ax	; // store integer converted left sample
1439 | 		lodsw
1440 | %else		
1441 | 		fstp	dword [esi]		; // store left sample
1442 | 		lodsd
1443 | %endif		
1444 | 		fld		dword [edi-4]
1445 | %ifdef GO4K_USE_16BIT_OUTPUT
1446 | 		push	eax
1447 | 		fmul	dword [c_32767]
1448 | 		fistp	dword [esp]
1449 | 		pop		eax
1450 | 		mov		word [esi],ax	; // store integer converted right sample
1451 | 		lodsw
1452 | %else				
1453 | 		fstp	dword [esi]		; // store right sample		
1454 | 		lodsd
1455 | %endif		
1456 | %endif		
1457 | %ifdef GO4K_USE_BUFFER_RECORDINGS			
1458 | 		xchg	esi, dword [esp+48]
1459 | %else
1460 | 		xchg	esi, dword [esp+44]
1461 | %endif
1462 | 		pop		ecx
1463 | 		inc		ecx
1464 | %ifdef GO4K_USE_GROOVE_PATTERN
1465 | 		mov		ebx, dword SAMPLES_PER_TICK
1466 | 		mov		eax, dword [esp]
1467 | 		and		eax, 0x0f
1468 | 		bt		dword [go4k_groove_pattern],eax
1469 | 		jnc		go4k_render_nogroove
1470 | 		sub		ebx, dword 3000
1471 | go4k_render_nogroove:				
1472 | 		cmp		ecx, ebx
1473 | %else
1474 | 		cmp		ecx, dword SAMPLES_PER_TICK
1475 | %endif
1476 | 		jl		go4k_render_sampleloop	
1477 | 	pop		ecx	
1478 | 	inc		ecx
1479 | 	cmp		ecx, dword MAX_TICKS
1480 | 	jl		go4k_render_tickloop
1481 | %ifdef GO4K_USE_BUFFER_RECORDINGS	
1482 | 	pop		ecx
1483 | %endif	
1484 | 	popad
1485 | 	ret		4      
1486 | 
1487 | %ifdef USE_SECTIONS
1488 | section		.g4kcodz	code	align=1
1489 | %else
1490 | section .text
1491 | %endif
1492 | ; //----------------------------------------------------------------------------------------
1493 | ; //	the magic behind it :)
1494 | ; //----------------------------------------------------------------------------------------
1495 | ; // IN		:		edi	= instrument pointer
1496 | ; // IN		:		esi	= instrumet values
1497 | ; // IN		: 		ebx = instrument instructions
1498 | ; // OUT	:		
1499 | ; // DIRTY	:
1500 | ; //----------------------------------------------------------------------------------------
1501 | go4k_VM_process:
1502 | 	lea		WRK, [edi+8]								; // get current workspace pointer
1503 | 	mov		ecx, WRK									; // ecx = workspace start
1504 | go4k_VM_process_loop:
1505 | 	movzx	eax, byte [ebx]								; // get command byte
1506 | 	inc		ebx
1507 | 	test	eax, eax	
1508 | 	je		go4k_VM_process_done						; // command byte = 0? so done
1509 | 	call	dword [eax*4+go4k_synth_commands]
1510 | 	add		WRK, MAX_WORKSPACE_SLOTS*4					; // go to next workspace slot
1511 | 	jmp		short go4k_VM_process_loop
1512 | go4k_VM_process_done:	
1513 | 	add		edi, go4k_instrument.size		; // go to next instrument voice
1514 | 	ret


--------------------------------------------------------------------------------