From 9227ba8b5d5da09a985cd9438095373d30bb4232 Mon Sep 17 00:00:00 2001 From: Alexander Klingenbeck Date: Mon, 15 May 2023 23:02:41 +0200 Subject: [PATCH] More bindings, more samples --- assets/shaders/glsl330/raymarching.fs | 430 ++++++ bindings/src/index.ts | 299 ++-- bindings/src/quickjs.ts | 10 +- examples/2d_camera_mouse_zoom.js | 2 +- examples/lib.raylib.d.ts | 272 ++++ examples/raymarching.js | 79 ++ generate-bindings.js | 310 ++-- src/bindings/js_raylib_core.h | 1890 +++++++++++++++++++++++++ thirdparty/raylib | 2 +- 9 files changed, 2972 insertions(+), 322 deletions(-) create mode 100644 assets/shaders/glsl330/raymarching.fs create mode 100644 examples/raymarching.js diff --git a/assets/shaders/glsl330/raymarching.fs b/assets/shaders/glsl330/raymarching.fs new file mode 100644 index 0000000..cc69a54 --- /dev/null +++ b/assets/shaders/glsl330/raymarching.fs @@ -0,0 +1,430 @@ +#version 330 + +// Input vertex attributes (from vertex shader) +in vec2 fragTexCoord; +in vec4 fragColor; + +// Output fragment color +out vec4 finalColor; + +uniform vec3 viewEye; +uniform vec3 viewCenter; +uniform float runTime; +uniform vec2 resolution; + +// The MIT License +// Copyright © 2013 Inigo Quilez +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: + +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. + +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +// A list of useful distance function to simple primitives, and an example on how to +// do some interesting boolean operations, repetition and displacement. +// +// More info here: http://www.iquilezles.org/www/articles/distfunctions/distfunctions.htm + +#define AA 1 // make this 1 is your machine is too slow + +//------------------------------------------------------------------ + +float sdPlane( vec3 p ) +{ + return p.y; +} + +float sdSphere( vec3 p, float s ) +{ + return length(p)-s; +} + +float sdBox( vec3 p, vec3 b ) +{ + vec3 d = abs(p) - b; + return min(max(d.x,max(d.y,d.z)),0.0) + length(max(d,0.0)); +} + +float sdEllipsoid( in vec3 p, in vec3 r ) +{ + return (length( p/r ) - 1.0) * min(min(r.x,r.y),r.z); +} + +float udRoundBox( vec3 p, vec3 b, float r ) +{ + return length(max(abs(p)-b,0.0))-r; +} + +float sdTorus( vec3 p, vec2 t ) +{ + return length( vec2(length(p.xz)-t.x,p.y) )-t.y; +} + +float sdHexPrism( vec3 p, vec2 h ) +{ + vec3 q = abs(p); +#if 0 + return max(q.z-h.y,max((q.x*0.866025+q.y*0.5),q.y)-h.x); +#else + float d1 = q.z-h.y; + float d2 = max((q.x*0.866025+q.y*0.5),q.y)-h.x; + return length(max(vec2(d1,d2),0.0)) + min(max(d1,d2), 0.); +#endif +} + +float sdCapsule( vec3 p, vec3 a, vec3 b, float r ) +{ + vec3 pa = p-a, ba = b-a; + float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 ); + return length( pa - ba*h ) - r; +} + +float sdEquilateralTriangle( in vec2 p ) +{ + const float k = sqrt(3.0); + p.x = abs(p.x) - 1.0; + p.y = p.y + 1.0/k; + if( p.x + k*p.y > 0.0 ) p = vec2( p.x - k*p.y, -k*p.x - p.y )/2.0; + p.x += 2.0 - 2.0*clamp( (p.x+2.0)/2.0, 0.0, 1.0 ); + return -length(p)*sign(p.y); +} + +float sdTriPrism( vec3 p, vec2 h ) +{ + vec3 q = abs(p); + float d1 = q.z-h.y; +#if 1 + // distance bound + float d2 = max(q.x*0.866025+p.y*0.5,-p.y)-h.x*0.5; +#else + // correct distance + h.x *= 0.866025; + float d2 = sdEquilateralTriangle(p.xy/h.x)*h.x; +#endif + return length(max(vec2(d1,d2),0.0)) + min(max(d1,d2), 0.); +} + +float sdCylinder( vec3 p, vec2 h ) +{ + vec2 d = abs(vec2(length(p.xz),p.y)) - h; + return min(max(d.x,d.y),0.0) + length(max(d,0.0)); +} + +float sdCone( in vec3 p, in vec3 c ) +{ + vec2 q = vec2( length(p.xz), p.y ); + float d1 = -q.y-c.z; + float d2 = max( dot(q,c.xy), q.y); + return length(max(vec2(d1,d2),0.0)) + min(max(d1,d2), 0.); +} + +float sdConeSection( in vec3 p, in float h, in float r1, in float r2 ) +{ + float d1 = -p.y - h; + float q = p.y - h; + float si = 0.5*(r1-r2)/h; + float d2 = max( sqrt( dot(p.xz,p.xz)*(1.0-si*si)) + q*si - r2, q ); + return length(max(vec2(d1,d2),0.0)) + min(max(d1,d2), 0.); +} + +float sdPryamid4(vec3 p, vec3 h ) // h = { cos a, sin a, height } +{ + // Tetrahedron = Octahedron - Cube + float box = sdBox( p - vec3(0,-2.0*h.z,0), vec3(2.0*h.z) ); + + float d = 0.0; + d = max( d, abs( dot(p, vec3( -h.x, h.y, 0 )) )); + d = max( d, abs( dot(p, vec3( h.x, h.y, 0 )) )); + d = max( d, abs( dot(p, vec3( 0, h.y, h.x )) )); + d = max( d, abs( dot(p, vec3( 0, h.y,-h.x )) )); + float octa = d - h.z; + return max(-box,octa); // Subtraction + } + +float length2( vec2 p ) +{ + return sqrt( p.x*p.x + p.y*p.y ); +} + +float length6( vec2 p ) +{ + p = p*p*p; p = p*p; + return pow( p.x + p.y, 1.0/6.0 ); +} + +float length8( vec2 p ) +{ + p = p*p; p = p*p; p = p*p; + return pow( p.x + p.y, 1.0/8.0 ); +} + +float sdTorus82( vec3 p, vec2 t ) +{ + vec2 q = vec2(length2(p.xz)-t.x,p.y); + return length8(q)-t.y; +} + +float sdTorus88( vec3 p, vec2 t ) +{ + vec2 q = vec2(length8(p.xz)-t.x,p.y); + return length8(q)-t.y; +} + +float sdCylinder6( vec3 p, vec2 h ) +{ + return max( length6(p.xz)-h.x, abs(p.y)-h.y ); +} + +//------------------------------------------------------------------ + +float opS( float d1, float d2 ) +{ + return max(-d2,d1); +} + +vec2 opU( vec2 d1, vec2 d2 ) +{ + return (d1.x0.0 ) tmax = min( tmax, tp1 ); + float tp2 = (1.6-ro.y)/rd.y; if( tp2>0.0 ) { if( ro.y>1.6 ) tmin = max( tmin, tp2 ); + else tmax = min( tmax, tp2 ); } +#endif + + float t = tmin; + float m = -1.0; + for( int i=0; i<64; i++ ) + { + float precis = 0.0005*t; + vec2 res = map( ro+rd*t ); + if( res.xtmax ) break; + t += res.x; + m = res.y; + } + + if( t>tmax ) m=-1.0; + return vec2( t, m ); +} + + +float calcSoftshadow( in vec3 ro, in vec3 rd, in float mint, in float tmax ) +{ + float res = 1.0; + float t = mint; + for( int i=0; i<16; i++ ) + { + float h = map( ro + rd*t ).x; + res = min( res, 8.0*h/t ); + t += clamp( h, 0.02, 0.10 ); + if( h<0.001 || t>tmax ) break; + } + return clamp( res, 0.0, 1.0 ); +} + +vec3 calcNormal( in vec3 pos ) +{ + vec2 e = vec2(1.0,-1.0)*0.5773*0.0005; + return normalize( e.xyy*map( pos + e.xyy ).x + + e.yyx*map( pos + e.yyx ).x + + e.yxy*map( pos + e.yxy ).x + + e.xxx*map( pos + e.xxx ).x ); + /* + vec3 eps = vec3( 0.0005, 0.0, 0.0 ); + vec3 nor = vec3( + map(pos+eps.xyy).x - map(pos-eps.xyy).x, + map(pos+eps.yxy).x - map(pos-eps.yxy).x, + map(pos+eps.yyx).x - map(pos-eps.yyx).x ); + return normalize(nor); + */ +} + +float calcAO( in vec3 pos, in vec3 nor ) +{ + float occ = 0.0; + float sca = 1.0; + for( int i=0; i<5; i++ ) + { + float hr = 0.01 + 0.12*float(i)/4.0; + vec3 aopos = nor * hr + pos; + float dd = map( aopos ).x; + occ += -(dd-hr)*sca; + sca *= 0.95; + } + return clamp( 1.0 - 3.0*occ, 0.0, 1.0 ); +} + +// http://iquilezles.org/www/articles/checkerfiltering/checkerfiltering.htm +float checkersGradBox( in vec2 p ) +{ + // filter kernel + vec2 w = fwidth(p) + 0.001; + // analytical integral (box filter) + vec2 i = 2.0*(abs(fract((p-0.5*w)*0.5)-0.5)-abs(fract((p+0.5*w)*0.5)-0.5))/w; + // xor pattern + return 0.5 - 0.5*i.x*i.y; +} + +vec3 render( in vec3 ro, in vec3 rd ) +{ + vec3 col = vec3(0.7, 0.9, 1.0) +rd.y*0.8; + vec2 res = castRay(ro,rd); + float t = res.x; + float m = res.y; + if( m>-0.5 ) + { + vec3 pos = ro + t*rd; + vec3 nor = calcNormal( pos ); + vec3 ref = reflect( rd, nor ); + + // material + col = 0.45 + 0.35*sin( vec3(0.05,0.08,0.10)*(m-1.0) ); + if( m<1.5 ) + { + + float f = checkersGradBox( 5.0*pos.xz ); + col = 0.3 + f*vec3(0.1); + } + + // lighting + float occ = calcAO( pos, nor ); + vec3 lig = normalize( vec3(cos(-0.4 * runTime), sin(0.7 * runTime), -0.6) ); + vec3 hal = normalize( lig-rd ); + float amb = clamp( 0.5+0.5*nor.y, 0.0, 1.0 ); + float dif = clamp( dot( nor, lig ), 0.0, 1.0 ); + float bac = clamp( dot( nor, normalize(vec3(-lig.x,0.0,-lig.z))), 0.0, 1.0 )*clamp( 1.0-pos.y,0.0,1.0); + float dom = smoothstep( -0.1, 0.1, ref.y ); + float fre = pow( clamp(1.0+dot(nor,rd),0.0,1.0), 2.0 ); + + dif *= calcSoftshadow( pos, lig, 0.02, 2.5 ); + dom *= calcSoftshadow( pos, ref, 0.02, 2.5 ); + + float spe = pow( clamp( dot( nor, hal ), 0.0, 1.0 ),16.0)* + dif * + (0.04 + 0.96*pow( clamp(1.0+dot(hal,rd),0.0,1.0), 5.0 )); + + vec3 lin = vec3(0.0); + lin += 1.30*dif*vec3(1.00,0.80,0.55); + lin += 0.40*amb*vec3(0.40,0.60,1.00)*occ; + lin += 0.50*dom*vec3(0.40,0.60,1.00)*occ; + lin += 0.50*bac*vec3(0.25,0.25,0.25)*occ; + lin += 0.25*fre*vec3(1.00,1.00,1.00)*occ; + col = col*lin; + col += 10.00*spe*vec3(1.00,0.90,0.70); + + col = mix( col, vec3(0.8,0.9,1.0), 1.0-exp( -0.0002*t*t*t ) ); + } + + return vec3( clamp(col,0.0,1.0) ); +} + +mat3 setCamera( in vec3 ro, in vec3 ta, float cr ) +{ + vec3 cw = normalize(ta-ro); + vec3 cp = vec3(sin(cr), cos(cr),0.0); + vec3 cu = normalize( cross(cw,cp) ); + vec3 cv = normalize( cross(cu,cw) ); + return mat3( cu, cv, cw ); +} + +void main() +{ + vec3 tot = vec3(0.0); +#if AA>1 + for( int m=0; m1 + } + tot /= float(AA*AA); +#endif + + finalColor = vec4( tot, 1.0 ); +} \ No newline at end of file diff --git a/bindings/src/index.ts b/bindings/src/index.ts index 7f8fa06..a5ec784 100644 --- a/bindings/src/index.ts +++ b/bindings/src/index.ts @@ -197,7 +197,7 @@ function main(){ core.addApiFunctionByName("MaximizeWindow") core.addApiFunctionByName("MinimizeWindow") core.addApiFunctionByName("RestoreWindow") - // SetWindowIcon + core.addApiFunctionByName("SetWindowIcon") // SetWindowIcons core.addApiFunctionByName("SetWindowTitle") core.addApiFunctionByName("SetWindowPosition") @@ -247,8 +247,8 @@ function main(){ core.addApiFunctionByName("EndMode3D") //core.addApiFunctionByName("BeginTextureMode") //core.addApiFunctionByName("EndTextureMode") - //core.addApiFunctionByName("BeginShaderMode") - //core.addApiFunctionByName("EndShaderMode") + core.addApiFunctionByName("BeginShaderMode") + core.addApiFunctionByName("EndShaderMode") core.addApiFunctionByName("BeginBlendMode") core.addApiFunctionByName("EndBlendMode") core.addApiFunctionByName("BeginScissorMode") @@ -261,24 +261,24 @@ function main(){ //core.addApiFunctionByName("UnloadVrStereoConfig") // Shader Management - // core.addApiFunctionByName("LoadShader") + core.addApiFunctionByName("LoadShader") // core.addApiFunctionByName("LoadShaderFromMemory") - // core.addApiFunctionByName("IsShaderReady") - // core.addApiFunctionByName("GetShaderLocation") - // core.addApiFunctionByName("GetShaderLocationAttrib") + core.addApiFunctionByName("IsShaderReady") + core.addApiFunctionByName("GetShaderLocation") + core.addApiFunctionByName("GetShaderLocationAttrib") // core.addApiFunctionByName("SetShaderValue") // core.addApiFunctionByName("SetShaderValueV") - // core.addApiFunctionByName("SetShaderValueMatrix") - // core.addApiFunctionByName("SetShaderValueTexture") - // // "UnloadShader" is destructor + core.addApiFunctionByName("SetShaderValueMatrix") + core.addApiFunctionByName("SetShaderValueTexture") + // "UnloadShader" called by finalizer // ScreenSpaceRelatedFunctions - //core.addApiFunctionByName("GetMouseRay") - //core.addApiFunctionByName("GetCameraMatrix") + core.addApiFunctionByName("GetMouseRay") + core.addApiFunctionByName("GetCameraMatrix") core.addApiFunctionByName("GetCameraMatrix2D") - //core.addApiFunctionByName("GetWorldToScreen") + core.addApiFunctionByName("GetWorldToScreen") core.addApiFunctionByName("GetScreenToWorld2D") - //core.addApiFunctionByName("GetScreenToWorldEx") + core.addApiFunctionByName("GetWorldToScreenEx") core.addApiFunctionByName("GetWorldToScreen2D") // Timing related functions @@ -393,8 +393,8 @@ function main(){ core.addApiFunctionByName("GetGesturePinchAngle") // Camera system functions - // core.addApiFunctionByName("UpdateCamera") - // core.addApiFunctionByName("UpdateCameraPro") + core.addApiFunctionByName("UpdateCamera") + core.addApiFunctionByName("UpdateCameraPro") //api.functions.forEach(x => console.log(`core.addApiFunctionByName("${x.name}")`)) @@ -481,54 +481,54 @@ function main(){ core.addApiFunctionByName("ImageCopy") core.addApiFunctionByName("ImageFromImage") core.addApiFunctionByName("ImageText") - // core.addApiFunctionByName("ImageTextEx") - // core.addApiFunctionByName("ImageFormat") - // core.addApiFunctionByName("ImageToPOT") - // core.addApiFunctionByName("ImageCrop") - // core.addApiFunctionByName("ImageAlphaCrop") - // core.addApiFunctionByName("ImageAlphaClear") - // core.addApiFunctionByName("ImageAlphaMask") - // core.addApiFunctionByName("ImageAlphaPremultiply") - // core.addApiFunctionByName("ImageBlurGaussian") - // core.addApiFunctionByName("ImageResize") - // core.addApiFunctionByName("ImageResizeNN") - // core.addApiFunctionByName("ImageResizeCanvas") - // core.addApiFunctionByName("ImageMipmaps") - // core.addApiFunctionByName("ImageDither") - // core.addApiFunctionByName("ImageFlipVertical") - // core.addApiFunctionByName("ImageFlipHorizontal") - // core.addApiFunctionByName("ImageRotateCW") - // core.addApiFunctionByName("ImageRotateCCW") - // core.addApiFunctionByName("ImageColorTint") - // core.addApiFunctionByName("ImageColorInvert") - // core.addApiFunctionByName("ImageColorGrayscale") - // core.addApiFunctionByName("ImageColorContrast") - // core.addApiFunctionByName("ImageColorBrightness") - // core.addApiFunctionByName("ImageColorReplace") - // core.addApiFunctionByName("LoadImageColors") - // core.addApiFunctionByName("LoadImagePalette") - // core.addApiFunctionByName("UnloadImageColors") - // core.addApiFunctionByName("UnloadImagePalette") + core.addApiFunctionByName("ImageTextEx") + core.addApiFunctionByName("ImageFormat") + core.addApiFunctionByName("ImageToPOT") + core.addApiFunctionByName("ImageCrop") + core.addApiFunctionByName("ImageAlphaCrop") + core.addApiFunctionByName("ImageAlphaClear") + core.addApiFunctionByName("ImageAlphaMask") + core.addApiFunctionByName("ImageAlphaPremultiply") + core.addApiFunctionByName("ImageBlurGaussian") + core.addApiFunctionByName("ImageResize") + core.addApiFunctionByName("ImageResizeNN") + core.addApiFunctionByName("ImageResizeCanvas") + core.addApiFunctionByName("ImageMipmaps") + core.addApiFunctionByName("ImageDither") + core.addApiFunctionByName("ImageFlipVertical") + core.addApiFunctionByName("ImageFlipHorizontal") + core.addApiFunctionByName("ImageRotateCW") + core.addApiFunctionByName("ImageRotateCCW") + core.addApiFunctionByName("ImageColorTint") + core.addApiFunctionByName("ImageColorInvert") + core.addApiFunctionByName("ImageColorGrayscale") + core.addApiFunctionByName("ImageColorContrast") + core.addApiFunctionByName("ImageColorBrightness") + core.addApiFunctionByName("ImageColorReplace") + //core.addApiFunctionByName("LoadImageColors") + //core.addApiFunctionByName("LoadImagePalette") + //core.addApiFunctionByName("UnloadImageColors") + //core.addApiFunctionByName("UnloadImagePalette") core.addApiFunctionByName("GetImageAlphaBorder") core.addApiFunctionByName("GetImageColor") // Image drawing functions - // core.addApiFunctionByName("ImageClearBackground") - // core.addApiFunctionByName("ImageDrawPixel") - // core.addApiFunctionByName("ImageDrawPixelV") - // core.addApiFunctionByName("ImageDrawLine") - // core.addApiFunctionByName("ImageDrawLineV") - // core.addApiFunctionByName("ImageDrawCircle") - // core.addApiFunctionByName("ImageDrawCircleV") - // core.addApiFunctionByName("ImageDrawCircleLines") - // core.addApiFunctionByName("ImageDrawCircleLinesV") - // core.addApiFunctionByName("ImageDrawRectangle") - // core.addApiFunctionByName("ImageDrawRectangleV") - // core.addApiFunctionByName("ImageDrawRectangleRec") - // core.addApiFunctionByName("ImageDrawRectangleLines") - // core.addApiFunctionByName("ImageDraw") - // core.addApiFunctionByName("ImageDrawText") - // core.addApiFunctionByName("ImageDrawTextEx") + core.addApiFunctionByName("ImageClearBackground") + core.addApiFunctionByName("ImageDrawPixel") + core.addApiFunctionByName("ImageDrawPixelV") + core.addApiFunctionByName("ImageDrawLine") + core.addApiFunctionByName("ImageDrawLineV") + core.addApiFunctionByName("ImageDrawCircle") + core.addApiFunctionByName("ImageDrawCircleV") + core.addApiFunctionByName("ImageDrawCircleLines") + core.addApiFunctionByName("ImageDrawCircleLinesV") + core.addApiFunctionByName("ImageDrawRectangle") + core.addApiFunctionByName("ImageDrawRectangleV") + core.addApiFunctionByName("ImageDrawRectangleRec") + core.addApiFunctionByName("ImageDrawRectangleLines") + core.addApiFunctionByName("ImageDraw") + core.addApiFunctionByName("ImageDrawText") + core.addApiFunctionByName("ImageDrawTextEx") // Texture loading functions core.addApiFunctionByName("LoadTexture") @@ -543,7 +543,7 @@ function main(){ // core.addApiFunctionByName("UpdateTextureRec") // Texture configuration functions - // core.addApiFunctionByName("GenTextureMipmaps") + core.addApiFunctionByName("GenTextureMipmaps") core.addApiFunctionByName("SetTextureFilter") core.addApiFunctionByName("SetTextureWrap") @@ -615,22 +615,7 @@ function main(){ // core.addApiFunctionByName("CodepointToUTF8") // Text strings management functions (no UTF-8 strings, only byte chars) - // Probably not needed - // core.addApiFunctionByName("TextCopy") - // core.addApiFunctionByName("TextIsEqual") - // core.addApiFunctionByName("TextLength") - // core.addApiFunctionByName("TextFormat") - // core.addApiFunctionByName("TextSubtext") - // core.addApiFunctionByName("TextReplace") - // core.addApiFunctionByName("TextInsert") - // core.addApiFunctionByName("TextJoin") - // core.addApiFunctionByName("TextSplit") - // core.addApiFunctionByName("TextAppend") - // core.addApiFunctionByName("TextFindIndex") - // core.addApiFunctionByName("TextToUpper") - // core.addApiFunctionByName("TextToLower") - // core.addApiFunctionByName("TextToPascal") - // core.addApiFunctionByName("TextToInteger") + // Not supported, use JS Stdlib instead // module: rmodels @@ -675,14 +660,15 @@ function main(){ core.addApiFunctionByName("DrawBillboardPro") // Mesh management functions - // core.addApiFunctionByName("UploadMesh") + // TODO: Refcounting needed? + core.addApiFunctionByName("UploadMesh") // core.addApiFunctionByName("UpdateMeshBuffer") // "UnloadMesh" called by finalizer //core.addApiFunctionByName("DrawMesh") // core.addApiFunctionByName("DrawMeshInstanced") core.addApiFunctionByName("ExportMesh") core.addApiFunctionByName("GetMeshBoundingBox") - // core.addApiFunctionByName("GenMeshTangents") + core.addApiFunctionByName("GenMeshTangents") // Mesh generation functions core.addApiFunctionByName("GenMeshPoly") @@ -753,8 +739,8 @@ function main(){ core.addApiFunctionByName("SetSoundPitch") core.addApiFunctionByName("SetSoundPan") core.addApiFunctionByName("WaveCopy") - // core.addApiFunctionByName("WaveCrop") - // core.addApiFunctionByName("WaveFormat") + core.addApiFunctionByName("WaveCrop") + core.addApiFunctionByName("WaveFormat") // core.addApiFunctionByName("LoadWaveSamples") // core.addApiFunctionByName("UnloadWaveSamples") @@ -838,81 +824,81 @@ function main(){ core.addApiFunctionByName("Vector3One") core.addApiFunctionByName("Vector3Add") core.addApiFunctionByName("Vector3AddValue") - // core.addApiFunctionByName("Vector3Subtract") - // core.addApiFunctionByName("Vector3SubtractValue") - // core.addApiFunctionByName("Vector3Scale") - // core.addApiFunctionByName("Vector3Multiply") - // core.addApiFunctionByName("Vector3CrossProduct") - // core.addApiFunctionByName("Vector3Perpendicular") - // core.addApiFunctionByName("Vector3Length") - // core.addApiFunctionByName("Vector3LengthSqr") - // core.addApiFunctionByName("Vector3DotProduct") - // core.addApiFunctionByName("Vector3Distance") - // core.addApiFunctionByName("Vector3DistanceSqr") - // core.addApiFunctionByName("Vector3Angle") - // core.addApiFunctionByName("Vector3Negate") - // core.addApiFunctionByName("Vector3Divide") - // core.addApiFunctionByName("Vector3Normalize") - // core.addApiFunctionByName("Vector3OrthoNormalize") - // core.addApiFunctionByName("Vector3Transform") - // core.addApiFunctionByName("Vector3RotateByQuaternion") - // core.addApiFunctionByName("Vector3RotateByAxisAngle") - // core.addApiFunctionByName("Vector3Lerp") - // core.addApiFunctionByName("Vector3Reflect") - // core.addApiFunctionByName("Vector3Min") - // core.addApiFunctionByName("Vector3Max") - // core.addApiFunctionByName("Vector3Barycenter") - // core.addApiFunctionByName("Vector3Unproject") - // core.addApiFunctionByName("Vector3ToFloatV") - // core.addApiFunctionByName("Vector3Invert") - // core.addApiFunctionByName("Vector3Clamp") - // core.addApiFunctionByName("Vector3ClampValue") - // core.addApiFunctionByName("Vector3Equals") - // core.addApiFunctionByName("Vector3Refract") - // core.addApiFunctionByName("MatrixDeterminant") - // core.addApiFunctionByName("MatrixTrace") - // core.addApiFunctionByName("MatrixTranspose") - // core.addApiFunctionByName("MatrixInvert") - // core.addApiFunctionByName("MatrixIdentity") - // core.addApiFunctionByName("MatrixAdd") - // core.addApiFunctionByName("MatrixSubtract") - // core.addApiFunctionByName("MatrixMultiply") - // core.addApiFunctionByName("MatrixTranslate") - // core.addApiFunctionByName("MatrixRotate") - // core.addApiFunctionByName("MatrixRotateX") - // core.addApiFunctionByName("MatrixRotateY") - // core.addApiFunctionByName("MatrixRotateZ") - // core.addApiFunctionByName("MatrixRotateXYZ") - // core.addApiFunctionByName("MatrixRotateZYX") - // core.addApiFunctionByName("MatrixScale") - // core.addApiFunctionByName("MatrixFrustum") - // core.addApiFunctionByName("MatrixPerspective") - // core.addApiFunctionByName("MatrixOrtho") - // core.addApiFunctionByName("MatrixLookAt") - // core.addApiFunctionByName("MatrixToFloatV") - // core.addApiFunctionByName("QuaternionAdd") - // core.addApiFunctionByName("QuaternionAddValue") - // core.addApiFunctionByName("QuaternionSubtract") - // core.addApiFunctionByName("QuaternionSubtractValue") - // core.addApiFunctionByName("QuaternionIdentity") - // core.addApiFunctionByName("QuaternionLength") - // core.addApiFunctionByName("QuaternionNormalize") - // core.addApiFunctionByName("QuaternionInvert") - // core.addApiFunctionByName("QuaternionMultiply") - // core.addApiFunctionByName("QuaternionScale") - // core.addApiFunctionByName("QuaternionDivide") - // core.addApiFunctionByName("QuaternionLerp") - // core.addApiFunctionByName("QuaternionNlerp") - // core.addApiFunctionByName("QuaternionSlerp") - // core.addApiFunctionByName("QuaternionFromVector3ToVector3") - // core.addApiFunctionByName("QuaternionFromMatrix") - // core.addApiFunctionByName("QuaternionToMatrix") - // core.addApiFunctionByName("QuaternionFromAxisAngle") - // core.addApiFunctionByName("QuaternionToAxisAngle") - // core.addApiFunctionByName("QuaternionFromEuler") - // core.addApiFunctionByName("QuaternionToEuler") - // core.addApiFunctionByName("QuaternionTransform") - // core.addApiFunctionByName("QuaternionEquals") + core.addApiFunctionByName("Vector3Subtract") + core.addApiFunctionByName("Vector3SubtractValue") + core.addApiFunctionByName("Vector3Scale") + core.addApiFunctionByName("Vector3Multiply") + core.addApiFunctionByName("Vector3CrossProduct") + core.addApiFunctionByName("Vector3Perpendicular") + core.addApiFunctionByName("Vector3Length") + core.addApiFunctionByName("Vector3LengthSqr") + core.addApiFunctionByName("Vector3DotProduct") + core.addApiFunctionByName("Vector3Distance") + core.addApiFunctionByName("Vector3DistanceSqr") + core.addApiFunctionByName("Vector3Angle") + core.addApiFunctionByName("Vector3Negate") + core.addApiFunctionByName("Vector3Divide") + core.addApiFunctionByName("Vector3Normalize") + //core.addApiFunctionByName("Vector3OrthoNormalize") + core.addApiFunctionByName("Vector3Transform") + core.addApiFunctionByName("Vector3RotateByQuaternion") + core.addApiFunctionByName("Vector3RotateByAxisAngle") + core.addApiFunctionByName("Vector3Lerp") + core.addApiFunctionByName("Vector3Reflect") + core.addApiFunctionByName("Vector3Min") + core.addApiFunctionByName("Vector3Max") + core.addApiFunctionByName("Vector3Barycenter") + core.addApiFunctionByName("Vector3Unproject") + //core.addApiFunctionByName("Vector3ToFloatV") + core.addApiFunctionByName("Vector3Invert") + core.addApiFunctionByName("Vector3Clamp") + core.addApiFunctionByName("Vector3ClampValue") + core.addApiFunctionByName("Vector3Equals") + core.addApiFunctionByName("Vector3Refract") + core.addApiFunctionByName("MatrixDeterminant") + core.addApiFunctionByName("MatrixTrace") + core.addApiFunctionByName("MatrixTranspose") + core.addApiFunctionByName("MatrixInvert") + core.addApiFunctionByName("MatrixIdentity") + core.addApiFunctionByName("MatrixAdd") + core.addApiFunctionByName("MatrixSubtract") + core.addApiFunctionByName("MatrixMultiply") + core.addApiFunctionByName("MatrixTranslate") + core.addApiFunctionByName("MatrixRotate") + core.addApiFunctionByName("MatrixRotateX") + core.addApiFunctionByName("MatrixRotateY") + core.addApiFunctionByName("MatrixRotateZ") + core.addApiFunctionByName("MatrixRotateXYZ") + core.addApiFunctionByName("MatrixRotateZYX") + core.addApiFunctionByName("MatrixScale") + core.addApiFunctionByName("MatrixFrustum") + core.addApiFunctionByName("MatrixPerspective") + core.addApiFunctionByName("MatrixOrtho") + core.addApiFunctionByName("MatrixLookAt") + //core.addApiFunctionByName("MatrixToFloatV") + core.addApiFunctionByName("QuaternionAdd") + core.addApiFunctionByName("QuaternionAddValue") + core.addApiFunctionByName("QuaternionSubtract") + core.addApiFunctionByName("QuaternionSubtractValue") + core.addApiFunctionByName("QuaternionIdentity") + core.addApiFunctionByName("QuaternionLength") + core.addApiFunctionByName("QuaternionNormalize") + core.addApiFunctionByName("QuaternionInvert") + core.addApiFunctionByName("QuaternionMultiply") + core.addApiFunctionByName("QuaternionScale") + core.addApiFunctionByName("QuaternionDivide") + core.addApiFunctionByName("QuaternionLerp") + core.addApiFunctionByName("QuaternionNlerp") + core.addApiFunctionByName("QuaternionSlerp") + core.addApiFunctionByName("QuaternionFromVector3ToVector3") + core.addApiFunctionByName("QuaternionFromMatrix") + core.addApiFunctionByName("QuaternionToMatrix") + core.addApiFunctionByName("QuaternionFromAxisAngle") + //core.addApiFunctionByName("QuaternionToAxisAngle") + core.addApiFunctionByName("QuaternionFromEuler") + core.addApiFunctionByName("QuaternionToEuler") + core.addApiFunctionByName("QuaternionTransform") + core.addApiFunctionByName("QuaternionEquals") api.defines.filter(x => x.type === "COLOR").map(x => ({ name: x.name, description: x.description, values: (x.value.match(/\{([^}]+)\}/) || "")[1].split(',').map(x => x.trim()) })).forEach(x => { core.exportGlobalStruct("Color", x.name, x.values, x.description) @@ -925,6 +911,7 @@ function main(){ api.enums.find(x => x.name === "MouseCursor")?.values.forEach(x => core.exportGlobalConstant(x.name, x.description)) api.enums.find(x => x.name === "PixelFormat")?.values.forEach(x => core.exportGlobalConstant(x.name, x.description)) api.enums.find(x => x.name === "CameraProjection")?.values.forEach(x => core.exportGlobalConstant(x.name, x.description)) + api.enums.find(x => x.name === "CameraMode")?.values.forEach(x => core.exportGlobalConstant(x.name, x.description)) core.writeTo("src/bindings/js_raylib_core.h") core.typings.writeTo("examples/lib.raylib.d.ts") } diff --git a/bindings/src/quickjs.ts b/bindings/src/quickjs.ts index 6649915..329d509 100644 --- a/bindings/src/quickjs.ts +++ b/bindings/src/quickjs.ts @@ -110,11 +110,13 @@ export abstract class GenericQuickJsGenerator extend break; default: const isConst = type.startsWith('const') - const classId = classIds[type.replace("const ", "")] + const isPointer = type.endsWith(' *') + const classId = classIds[type.replace("const ", "").replace(" *", "")] if(!classId) throw new Error("Cannot convert into parameter type: " + type) - this.jsOpqToStructPtr(type, name+"_ptr", src, classId) - this.statement(`if(${name}_ptr == NULL) return JS_EXCEPTION`) - this.declare(name, type, false, `*${name}_ptr`) + const suffix = isPointer ? "" : "_ptr" + this.jsOpqToStructPtr(type.replace(" *", ""), name+suffix, src, classId) + this.statement(`if(${name+suffix} == NULL) return JS_EXCEPTION`) + if(!isPointer) this.declare(name, type, false, `*${name}_ptr`) } } diff --git a/examples/2d_camera_mouse_zoom.js b/examples/2d_camera_mouse_zoom.js index c8a25c6..cff2496 100644 --- a/examples/2d_camera_mouse_zoom.js +++ b/examples/2d_camera_mouse_zoom.js @@ -25,7 +25,7 @@ for (const key in rl) { // Translate based on mouse right click if (isMouseButtonDown(MOUSE_BUTTON_RIGHT)) { - const delta = getMouseDelta(); + let delta = getMouseDelta(); delta = vector2Scale(delta, -1.0/camera.zoom); camera.target = vector2Add(camera.target, delta); diff --git a/examples/lib.raylib.d.ts b/examples/lib.raylib.d.ts index cc52c1a..d26d96c 100644 --- a/examples/lib.raylib.d.ts +++ b/examples/lib.raylib.d.ts @@ -229,6 +229,8 @@ declare function maximizeWindow(): void; declare function minimizeWindow(): void; /** Set window state: not minimized/maximized (only PLATFORM_DESKTOP) */ declare function restoreWindow(): void; +/** Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP) */ +declare function setWindowIcon(image: Image): void; /** Set title for window (only PLATFORM_DESKTOP) */ declare function setWindowTitle(title: string): void; /** Set window position on screen (only PLATFORM_DESKTOP) */ @@ -305,6 +307,10 @@ declare function endMode2D(): void; declare function beginMode3D(camera: Camera3D): void; /** Ends 3D mode and returns to default 2D orthographic mode */ declare function endMode3D(): void; +/** Begin custom shader drawing */ +declare function beginShaderMode(shader: Shader): void; +/** End custom shader drawing (use default shader) */ +declare function endShaderMode(): void; /** Begin blending mode (alpha, additive, multiplied, subtract, custom) */ declare function beginBlendMode(mode: number): void; /** End blending mode (reset to default: alpha blending) */ @@ -313,10 +319,30 @@ declare function endBlendMode(): void; declare function beginScissorMode(x: number, y: number, width: number, height: number): void; /** End scissor mode */ declare function endScissorMode(): void; +/** Load shader from files and bind default locations */ +declare function loadShader(vsFileName: string, fsFileName: string): Shader; +/** Check if a shader is ready */ +declare function isShaderReady(shader: Shader): boolean; +/** Get shader uniform location */ +declare function getShaderLocation(shader: Shader, uniformName: string): number; +/** Get shader attribute location */ +declare function getShaderLocationAttrib(shader: Shader, attribName: string): number; +/** Set shader uniform value (matrix 4x4) */ +declare function setShaderValueMatrix(shader: Shader, locIndex: number, mat: Matrix): void; +/** Set shader uniform value for texture (sampler2d) */ +declare function setShaderValueTexture(shader: Shader, locIndex: number, texture: Texture2D): void; +/** Get a ray trace from mouse position */ +declare function getMouseRay(mousePosition: Vector2, camera: Camera): Ray; +/** Get camera transform matrix (view matrix) */ +declare function getCameraMatrix(camera: Camera): Matrix; /** Get camera 2d transform matrix */ declare function getCameraMatrix2D(camera: Camera2D): Matrix; +/** Get the screen space position for a 3d world space position */ +declare function getWorldToScreen(position: Vector3, camera: Camera): Vector2; /** Get the world space position for a 2d camera screen space position */ declare function getScreenToWorld2D(position: Vector2, camera: Camera2D): Vector2; +/** Get size position for a 3d world space position */ +declare function getWorldToScreenEx(position: Vector3, camera: Camera, width: number, height: number): Vector2; /** Get the screen space position for a 2d camera world space position */ declare function getWorldToScreen2D(position: Vector2, camera: Camera2D): Vector2; /** Set target FPS (maximum) */ @@ -463,6 +489,10 @@ declare function getGestureDragAngle(): number; declare function getGesturePinchVector(): Vector2; /** Get gesture pinch angle */ declare function getGesturePinchAngle(): number; +/** Update camera position for selected mode */ +declare function updateCamera(camera: Camera *, mode: number): void; +/** Update camera movement/rotation */ +declare function updateCameraPro(camera: Camera *, movement: Vector3, rotation: Vector3, zoom: number): void; /** Draw a pixel */ declare function drawPixel(posX: number, posY: number, color: Color): void; /** Draw a pixel (Vector version) */ @@ -583,10 +613,90 @@ declare function imageCopy(image: Image): Image; declare function imageFromImage(image: Image, rec: Rectangle): Image; /** Create an image from text (default font) */ declare function imageText(text: string, fontSize: number, color: Color): Image; +/** Create an image from text (custom sprite font) */ +declare function imageTextEx(font: Font, text: string, fontSize: number, spacing: number, tint: Color): Image; +/** Convert image data to desired format */ +declare function imageFormat(image: Image *, newFormat: number): void; +/** Convert image to POT (power-of-two) */ +declare function imageToPOT(image: Image *, fill: Color): void; +/** Crop an image to a defined rectangle */ +declare function imageCrop(image: Image *, crop: Rectangle): void; +/** Crop image depending on alpha value */ +declare function imageAlphaCrop(image: Image *, threshold: number): void; +/** Clear alpha channel to desired color */ +declare function imageAlphaClear(image: Image *, color: Color, threshold: number): void; +/** Apply alpha mask to image */ +declare function imageAlphaMask(image: Image *, alphaMask: Image): void; +/** Premultiply alpha channel */ +declare function imageAlphaPremultiply(image: Image *): void; +/** Apply Gaussian blur using a box blur approximation */ +declare function imageBlurGaussian(image: Image *, blurSize: number): void; +/** Resize image (Bicubic scaling algorithm) */ +declare function imageResize(image: Image *, newWidth: number, newHeight: number): void; +/** Resize image (Nearest-Neighbor scaling algorithm) */ +declare function imageResizeNN(image: Image *, newWidth: number, newHeight: number): void; +/** Resize canvas and fill with color */ +declare function imageResizeCanvas(image: Image *, newWidth: number, newHeight: number, offsetX: number, offsetY: number, fill: Color): void; +/** Compute all mipmap levels for a provided image */ +declare function imageMipmaps(image: Image *): void; +/** Dither image data to 16bpp or lower (Floyd-Steinberg dithering) */ +declare function imageDither(image: Image *, rBpp: number, gBpp: number, bBpp: number, aBpp: number): void; +/** Flip image vertically */ +declare function imageFlipVertical(image: Image *): void; +/** Flip image horizontally */ +declare function imageFlipHorizontal(image: Image *): void; +/** Rotate image clockwise 90deg */ +declare function imageRotateCW(image: Image *): void; +/** Rotate image counter-clockwise 90deg */ +declare function imageRotateCCW(image: Image *): void; +/** Modify image color: tint */ +declare function imageColorTint(image: Image *, color: Color): void; +/** Modify image color: invert */ +declare function imageColorInvert(image: Image *): void; +/** Modify image color: grayscale */ +declare function imageColorGrayscale(image: Image *): void; +/** Modify image color: contrast (-100 to 100) */ +declare function imageColorContrast(image: Image *, contrast: number): void; +/** Modify image color: brightness (-255 to 255) */ +declare function imageColorBrightness(image: Image *, brightness: number): void; +/** Modify image color: replace color */ +declare function imageColorReplace(image: Image *, color: Color, replace: Color): void; /** Get image alpha border rectangle */ declare function getImageAlphaBorder(image: Image, threshold: number): Rectangle; /** Get image pixel color at (x, y) position */ declare function getImageColor(image: Image, x: number, y: number): Color; +/** Clear image background with given color */ +declare function imageClearBackground(dst: Image *, color: Color): void; +/** Draw pixel within an image */ +declare function imageDrawPixel(dst: Image *, posX: number, posY: number, color: Color): void; +/** Draw pixel within an image (Vector version) */ +declare function imageDrawPixelV(dst: Image *, position: Vector2, color: Color): void; +/** Draw line within an image */ +declare function imageDrawLine(dst: Image *, startPosX: number, startPosY: number, endPosX: number, endPosY: number, color: Color): void; +/** Draw line within an image (Vector version) */ +declare function imageDrawLineV(dst: Image *, start: Vector2, end: Vector2, color: Color): void; +/** Draw a filled circle within an image */ +declare function imageDrawCircle(dst: Image *, centerX: number, centerY: number, radius: number, color: Color): void; +/** Draw a filled circle within an image (Vector version) */ +declare function imageDrawCircleV(dst: Image *, center: Vector2, radius: number, color: Color): void; +/** Draw circle outline within an image */ +declare function imageDrawCircleLines(dst: Image *, centerX: number, centerY: number, radius: number, color: Color): void; +/** Draw circle outline within an image (Vector version) */ +declare function imageDrawCircleLinesV(dst: Image *, center: Vector2, radius: number, color: Color): void; +/** Draw rectangle within an image */ +declare function imageDrawRectangle(dst: Image *, posX: number, posY: number, width: number, height: number, color: Color): void; +/** Draw rectangle within an image (Vector version) */ +declare function imageDrawRectangleV(dst: Image *, position: Vector2, size: Vector2, color: Color): void; +/** Draw rectangle within an image */ +declare function imageDrawRectangleRec(dst: Image *, rec: Rectangle, color: Color): void; +/** Draw rectangle lines within an image */ +declare function imageDrawRectangleLines(dst: Image *, rec: Rectangle, thick: number, color: Color): void; +/** Draw a source image within a destination image (tint applied to source) */ +declare function imageDraw(dst: Image *, src: Image, srcRec: Rectangle, dstRec: Rectangle, tint: Color): void; +/** Draw text (using default font) within an image (destination) */ +declare function imageDrawText(dst: Image *, text: string, posX: number, posY: number, fontSize: number, color: Color): void; +/** Draw text (custom sprite font) within an image (destination) */ +declare function imageDrawTextEx(dst: Image *, font: Font, text: string, position: Vector2, fontSize: number, spacing: number, tint: Color): void; /** Load texture from file into GPU memory (VRAM) */ declare function loadTexture(fileName: string): Texture2D; /** Load texture from image data */ @@ -595,6 +705,8 @@ declare function loadTextureFromImage(image: Image): Texture2D; declare function loadTextureCubemap(image: Image, layout: number): TextureCubemap; /** Check if a texture is ready */ declare function isTextureReady(texture: Texture2D): boolean; +/** Generate GPU mipmaps for a texture */ +declare function genTextureMipmaps(texture: Texture2D *): void; /** Set texture scaling filter mode */ declare function setTextureFilter(texture: Texture2D, filter: number): void; /** Set texture wrapping mode */ @@ -725,10 +837,14 @@ declare function drawBillboard(camera: Camera, texture: Texture2D, position: Vec declare function drawBillboardRec(camera: Camera, texture: Texture2D, source: Rectangle, position: Vector3, size: Vector2, tint: Color): void; /** Draw a billboard texture defined by source and rotation */ declare function drawBillboardPro(camera: Camera, texture: Texture2D, source: Rectangle, position: Vector3, up: Vector3, size: Vector2, origin: Vector2, rotation: number, tint: Color): void; +/** Upload mesh vertex data in GPU and provide VAO/VBO ids */ +declare function uploadMesh(mesh: Mesh *, dynamic: boolean): void; /** Export mesh data to file, returns true on success */ declare function exportMesh(mesh: Mesh, fileName: string): boolean; /** Compute mesh bounding box limits */ declare function getMeshBoundingBox(mesh: Mesh): BoundingBox; +/** Compute mesh tangents */ +declare function genMeshTangents(mesh: Mesh *): void; /** Generate polygonal mesh */ declare function genMeshPoly(sides: number, radius: number): Mesh; /** Generate plane mesh (with subdivisions) */ @@ -805,6 +921,10 @@ declare function setSoundPitch(sound: Sound, pitch: number): void; declare function setSoundPan(sound: Sound, pan: number): void; /** Copy a wave to a new wave */ declare function waveCopy(wave: Wave): Wave; +/** Crop a wave to defined samples range */ +declare function waveCrop(wave: Wave *, initSample: number, finalSample: number): void; +/** Convert wave data to desired format */ +declare function waveFormat(wave: Wave *, sampleRate: number, sampleSize: number, channels: number): void; /** Load music stream from file */ declare function loadMusicStream(fileName: string): Music; /** Checks if a music stream is ready */ @@ -907,6 +1027,148 @@ declare function vector3One(): Vector3; declare function vector3Add(v1: Vector3, v2: Vector3): Vector3; /** */ declare function vector3AddValue(v: Vector3, add: number): Vector3; +/** */ +declare function vector3Subtract(v1: Vector3, v2: Vector3): Vector3; +/** */ +declare function vector3SubtractValue(v: Vector3, sub: number): Vector3; +/** */ +declare function vector3Scale(v: Vector3, scalar: number): Vector3; +/** */ +declare function vector3Multiply(v1: Vector3, v2: Vector3): Vector3; +/** */ +declare function vector3CrossProduct(v1: Vector3, v2: Vector3): Vector3; +/** */ +declare function vector3Perpendicular(v: Vector3): Vector3; +/** */ +declare function vector3Length(v: const Vector3): number; +/** */ +declare function vector3LengthSqr(v: const Vector3): number; +/** */ +declare function vector3DotProduct(v1: Vector3, v2: Vector3): number; +/** */ +declare function vector3Distance(v1: Vector3, v2: Vector3): number; +/** */ +declare function vector3DistanceSqr(v1: Vector3, v2: Vector3): number; +/** */ +declare function vector3Angle(v1: Vector3, v2: Vector3): number; +/** */ +declare function vector3Negate(v: Vector3): Vector3; +/** */ +declare function vector3Divide(v1: Vector3, v2: Vector3): Vector3; +/** */ +declare function vector3Normalize(v: Vector3): Vector3; +/** */ +declare function vector3Transform(v: Vector3, mat: Matrix): Vector3; +/** */ +declare function vector3RotateByQuaternion(v: Vector3, q: Quaternion): Vector3; +/** */ +declare function vector3RotateByAxisAngle(v: Vector3, axis: Vector3, angle: number): Vector3; +/** */ +declare function vector3Lerp(v1: Vector3, v2: Vector3, amount: number): Vector3; +/** */ +declare function vector3Reflect(v: Vector3, normal: Vector3): Vector3; +/** */ +declare function vector3Min(v1: Vector3, v2: Vector3): Vector3; +/** */ +declare function vector3Max(v1: Vector3, v2: Vector3): Vector3; +/** */ +declare function vector3Barycenter(p: Vector3, a: Vector3, b: Vector3, c: Vector3): Vector3; +/** */ +declare function vector3Unproject(source: Vector3, projection: Matrix, view: Matrix): Vector3; +/** */ +declare function vector3Invert(v: Vector3): Vector3; +/** */ +declare function vector3Clamp(v: Vector3, min: Vector3, max: Vector3): Vector3; +/** */ +declare function vector3ClampValue(v: Vector3, min: number, max: number): Vector3; +/** */ +declare function vector3Equals(p: Vector3, q: Vector3): number; +/** */ +declare function vector3Refract(v: Vector3, n: Vector3, r: number): Vector3; +/** */ +declare function matrixDeterminant(mat: Matrix): number; +/** */ +declare function matrixTrace(mat: Matrix): number; +/** */ +declare function matrixTranspose(mat: Matrix): Matrix; +/** */ +declare function matrixInvert(mat: Matrix): Matrix; +/** */ +declare function matrixIdentity(): Matrix; +/** */ +declare function matrixAdd(left: Matrix, right: Matrix): Matrix; +/** */ +declare function matrixSubtract(left: Matrix, right: Matrix): Matrix; +/** */ +declare function matrixMultiply(left: Matrix, right: Matrix): Matrix; +/** */ +declare function matrixTranslate(x: number, y: number, z: number): Matrix; +/** */ +declare function matrixRotate(axis: Vector3, angle: number): Matrix; +/** */ +declare function matrixRotateX(angle: number): Matrix; +/** */ +declare function matrixRotateY(angle: number): Matrix; +/** */ +declare function matrixRotateZ(angle: number): Matrix; +/** */ +declare function matrixRotateXYZ(angle: Vector3): Matrix; +/** */ +declare function matrixRotateZYX(angle: Vector3): Matrix; +/** */ +declare function matrixScale(x: number, y: number, z: number): Matrix; +/** */ +declare function matrixFrustum(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix; +/** */ +declare function matrixPerspective(fovy: number, aspect: number, near: number, far: number): Matrix; +/** */ +declare function matrixOrtho(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix; +/** */ +declare function matrixLookAt(eye: Vector3, target: Vector3, up: Vector3): Matrix; +/** */ +declare function quaternionAdd(q1: Quaternion, q2: Quaternion): Quaternion; +/** */ +declare function quaternionAddValue(q: Quaternion, add: number): Quaternion; +/** */ +declare function quaternionSubtract(q1: Quaternion, q2: Quaternion): Quaternion; +/** */ +declare function quaternionSubtractValue(q: Quaternion, sub: number): Quaternion; +/** */ +declare function quaternionIdentity(): Quaternion; +/** */ +declare function quaternionLength(q: Quaternion): number; +/** */ +declare function quaternionNormalize(q: Quaternion): Quaternion; +/** */ +declare function quaternionInvert(q: Quaternion): Quaternion; +/** */ +declare function quaternionMultiply(q1: Quaternion, q2: Quaternion): Quaternion; +/** */ +declare function quaternionScale(q: Quaternion, mul: number): Quaternion; +/** */ +declare function quaternionDivide(q1: Quaternion, q2: Quaternion): Quaternion; +/** */ +declare function quaternionLerp(q1: Quaternion, q2: Quaternion, amount: number): Quaternion; +/** */ +declare function quaternionNlerp(q1: Quaternion, q2: Quaternion, amount: number): Quaternion; +/** */ +declare function quaternionSlerp(q1: Quaternion, q2: Quaternion, amount: number): Quaternion; +/** */ +declare function quaternionFromVector3ToVector3(from: Vector3, to: Vector3): Quaternion; +/** */ +declare function quaternionFromMatrix(mat: Matrix): Quaternion; +/** */ +declare function quaternionToMatrix(q: Quaternion): Matrix; +/** */ +declare function quaternionFromAxisAngle(axis: Vector3, angle: number): Quaternion; +/** */ +declare function quaternionFromEuler(pitch: number, yaw: number, roll: number): Quaternion; +/** */ +declare function quaternionToEuler(q: Quaternion): Vector3; +/** */ +declare function quaternionTransform(q: Quaternion, mat: Matrix): Quaternion; +/** */ +declare function quaternionEquals(p: Quaternion, q: Quaternion): number; /** Light Gray */ declare var LIGHTGRAY: Color; /** Gray */ @@ -1323,3 +1585,13 @@ declare var PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: number; declare var CAMERA_PERSPECTIVE: number; /** Orthographic projection */ declare var CAMERA_ORTHOGRAPHIC: number; +/** Custom camera */ +declare var CAMERA_CUSTOM: number; +/** Free camera */ +declare var CAMERA_FREE: number; +/** Orbital camera */ +declare var CAMERA_ORBITAL: number; +/** First person camera */ +declare var CAMERA_FIRST_PERSON: number; +/** Third person camera */ +declare var CAMERA_THIRD_PERSON: number; diff --git a/examples/raymarching.js b/examples/raymarching.js new file mode 100644 index 0000000..a9fbd9d --- /dev/null +++ b/examples/raymarching.js @@ -0,0 +1,79 @@ +// Initialization +//-------------------------------------------------------------------------------------- +const screenWidth = 800; +const screenHeight = 450; + +setConfigFlags(FLAG_WINDOW_RESIZABLE); +initWindow(screenWidth, screenHeight, "raylib [shaders] example - raymarching shapes"); + +const position = new Vector3(2.5, 2.5, 3.0); // Camera position +const target = new Vector3(0.0, 0.0, 0.7); // Camera looking at point +const up = new Vector3(0.0, 1.0, 0.0); // Camera up vector (rotation towards target) +const fovy = 65.0; // Camera field-of-view Y +const projection = CAMERA_PERSPECTIVE; // Camera projection type +const camera = new Camera3D(position,target, up, fovy, projection) + +// Load raymarching shader +// NOTE: Defining 0 (NULL) for vertex shader forces usage of internal default vertex shader +const shader = loadShader(0, "assets/shaders/glsl330/raymarching.fs"); + +// Get shader locations for required uniforms +const viewEyeLoc = getShaderLocation(shader, "viewEye"); +const viewCenterLoc = getShaderLocation(shader, "viewCenter"); +const runTimeLoc = getShaderLocation(shader, "runTime"); +const resolutionLoc = getShaderLocation(shader, "resolution"); + +let resolution = new Vector2(screenWidth, screenHeight); +setShaderValue(shader, resolutionLoc, resolution, SHADER_UNIFORM_VEC2); + +let runTime = 0.0; + +disableCursor(); // Limit cursor to relative movement inside the window +setTargetFPS(60); // Set our game to run at 60 frames-per-second +//-------------------------------------------------------------------------------------- + +// Main game loop +while (!windowShouldClose()) // Detect window close button or ESC key +{ + // Update + //---------------------------------------------------------------------------------- + updateCamera(camera, CAMERA_FIRST_PERSON); + + const deltaTime = getFrameTime(); + runTime += deltaTime; + + // Set shader required uniform values + setShaderValue(shader, viewEyeLoc, position, SHADER_UNIFORM_VEC3); + setShaderValue(shader, viewCenterLoc, target, SHADER_UNIFORM_VEC3); + setShaderValue(shader, runTimeLoc, runTime, SHADER_UNIFORM_FLOAT); + + // Check if screen is resized + if (isWindowResized()) + { + resolution = new Vector2(getScreenWidth(),getScreenHeight()) + setShaderValue(shader, resolutionLoc, resolution, SHADER_UNIFORM_VEC2); + } + //---------------------------------------------------------------------------------- + + // Draw + //---------------------------------------------------------------------------------- + beginDrawing(); + + clearBackground(RAYWHITE); + + // We only draw a white full-screen rectangle, + // frame is generated in shader using raymarching + beginShaderMode(shader); + drawRectangle(0, 0, getScreenWidth(), getScreenHeight(), WHITE); + endShaderMode(); + + drawText("(c) Raymarching shader by Iñigo Quilez. MIT License.", getScreenWidth() - 280, getScreenHeight() - 20, 10, BLACK); + + endDrawing(); + //---------------------------------------------------------------------------------- +} + +// De-Initialization +//-------------------------------------------------------------------------------------- +closeWindow(); // Close window and OpenGL context +//-------------------------------------------------------------------------------------- diff --git a/generate-bindings.js b/generate-bindings.js index e84af11..6420ac7 100644 --- a/generate-bindings.js +++ b/generate-bindings.js @@ -379,12 +379,15 @@ class GenericQuickJsGenerator extends generation_1.GenericCodeGenerator { break; default: const isConst = type.startsWith('const'); - const classId = classIds[type.replace("const ", "")]; + const isPointer = type.endsWith(' *'); + const classId = classIds[type.replace("const ", "").replace(" *", "")]; if (!classId) throw new Error("Cannot convert into parameter type: " + type); - this.jsOpqToStructPtr(type, name + "_ptr", src, classId); - this.statement(`if(${name}_ptr == NULL) return JS_EXCEPTION`); - this.declare(name, type, false, `*${name}_ptr`); + const suffix = isPointer ? "" : "_ptr"; + this.jsOpqToStructPtr(type.replace(" *", ""), name + suffix, src, classId); + this.statement(`if(${name + suffix} == NULL) return JS_EXCEPTION`); + if (!isPointer) + this.declare(name, type, false, `*${name}_ptr`); } } jsToJs(type, name, src, classIds = {}) { @@ -990,7 +993,7 @@ function main() { core.addApiFunctionByName("MaximizeWindow"); core.addApiFunctionByName("MinimizeWindow"); core.addApiFunctionByName("RestoreWindow"); - // SetWindowIcon + core.addApiFunctionByName("SetWindowIcon"); // SetWindowIcons core.addApiFunctionByName("SetWindowTitle"); core.addApiFunctionByName("SetWindowPosition"); @@ -1037,8 +1040,8 @@ function main() { core.addApiFunctionByName("EndMode3D"); //core.addApiFunctionByName("BeginTextureMode") //core.addApiFunctionByName("EndTextureMode") - //core.addApiFunctionByName("BeginShaderMode") - //core.addApiFunctionByName("EndShaderMode") + core.addApiFunctionByName("BeginShaderMode"); + core.addApiFunctionByName("EndShaderMode"); core.addApiFunctionByName("BeginBlendMode"); core.addApiFunctionByName("EndBlendMode"); core.addApiFunctionByName("BeginScissorMode"); @@ -1049,23 +1052,23 @@ function main() { //core.addApiFunctionByName("LoadVrStereoConfig") //core.addApiFunctionByName("UnloadVrStereoConfig") // Shader Management - // core.addApiFunctionByName("LoadShader") + core.addApiFunctionByName("LoadShader"); // core.addApiFunctionByName("LoadShaderFromMemory") - // core.addApiFunctionByName("IsShaderReady") - // core.addApiFunctionByName("GetShaderLocation") - // core.addApiFunctionByName("GetShaderLocationAttrib") + core.addApiFunctionByName("IsShaderReady"); + core.addApiFunctionByName("GetShaderLocation"); + core.addApiFunctionByName("GetShaderLocationAttrib"); // core.addApiFunctionByName("SetShaderValue") // core.addApiFunctionByName("SetShaderValueV") - // core.addApiFunctionByName("SetShaderValueMatrix") - // core.addApiFunctionByName("SetShaderValueTexture") - // // "UnloadShader" is destructor + core.addApiFunctionByName("SetShaderValueMatrix"); + core.addApiFunctionByName("SetShaderValueTexture"); + // "UnloadShader" called by finalizer // ScreenSpaceRelatedFunctions - //core.addApiFunctionByName("GetMouseRay") - //core.addApiFunctionByName("GetCameraMatrix") + core.addApiFunctionByName("GetMouseRay"); + core.addApiFunctionByName("GetCameraMatrix"); core.addApiFunctionByName("GetCameraMatrix2D"); - //core.addApiFunctionByName("GetWorldToScreen") + core.addApiFunctionByName("GetWorldToScreen"); core.addApiFunctionByName("GetScreenToWorld2D"); - //core.addApiFunctionByName("GetScreenToWorldEx") + core.addApiFunctionByName("GetWorldToScreenEx"); core.addApiFunctionByName("GetWorldToScreen2D"); // Timing related functions core.addApiFunctionByName("SetTargetFPS"); @@ -1169,8 +1172,8 @@ function main() { core.addApiFunctionByName("GetGesturePinchVector"); core.addApiFunctionByName("GetGesturePinchAngle"); // Camera system functions - // core.addApiFunctionByName("UpdateCamera") - // core.addApiFunctionByName("UpdateCameraPro") + core.addApiFunctionByName("UpdateCamera"); + core.addApiFunctionByName("UpdateCameraPro"); //api.functions.forEach(x => console.log(`core.addApiFunctionByName("${x.name}")`)) // module: rshapes // TODO: Do we need ref-counting here? @@ -1250,53 +1253,53 @@ function main() { core.addApiFunctionByName("ImageCopy"); core.addApiFunctionByName("ImageFromImage"); core.addApiFunctionByName("ImageText"); - // core.addApiFunctionByName("ImageTextEx") - // core.addApiFunctionByName("ImageFormat") - // core.addApiFunctionByName("ImageToPOT") - // core.addApiFunctionByName("ImageCrop") - // core.addApiFunctionByName("ImageAlphaCrop") - // core.addApiFunctionByName("ImageAlphaClear") - // core.addApiFunctionByName("ImageAlphaMask") - // core.addApiFunctionByName("ImageAlphaPremultiply") - // core.addApiFunctionByName("ImageBlurGaussian") - // core.addApiFunctionByName("ImageResize") - // core.addApiFunctionByName("ImageResizeNN") - // core.addApiFunctionByName("ImageResizeCanvas") - // core.addApiFunctionByName("ImageMipmaps") - // core.addApiFunctionByName("ImageDither") - // core.addApiFunctionByName("ImageFlipVertical") - // core.addApiFunctionByName("ImageFlipHorizontal") - // core.addApiFunctionByName("ImageRotateCW") - // core.addApiFunctionByName("ImageRotateCCW") - // core.addApiFunctionByName("ImageColorTint") - // core.addApiFunctionByName("ImageColorInvert") - // core.addApiFunctionByName("ImageColorGrayscale") - // core.addApiFunctionByName("ImageColorContrast") - // core.addApiFunctionByName("ImageColorBrightness") - // core.addApiFunctionByName("ImageColorReplace") - // core.addApiFunctionByName("LoadImageColors") - // core.addApiFunctionByName("LoadImagePalette") - // core.addApiFunctionByName("UnloadImageColors") - // core.addApiFunctionByName("UnloadImagePalette") + core.addApiFunctionByName("ImageTextEx"); + core.addApiFunctionByName("ImageFormat"); + core.addApiFunctionByName("ImageToPOT"); + core.addApiFunctionByName("ImageCrop"); + core.addApiFunctionByName("ImageAlphaCrop"); + core.addApiFunctionByName("ImageAlphaClear"); + core.addApiFunctionByName("ImageAlphaMask"); + core.addApiFunctionByName("ImageAlphaPremultiply"); + core.addApiFunctionByName("ImageBlurGaussian"); + core.addApiFunctionByName("ImageResize"); + core.addApiFunctionByName("ImageResizeNN"); + core.addApiFunctionByName("ImageResizeCanvas"); + core.addApiFunctionByName("ImageMipmaps"); + core.addApiFunctionByName("ImageDither"); + core.addApiFunctionByName("ImageFlipVertical"); + core.addApiFunctionByName("ImageFlipHorizontal"); + core.addApiFunctionByName("ImageRotateCW"); + core.addApiFunctionByName("ImageRotateCCW"); + core.addApiFunctionByName("ImageColorTint"); + core.addApiFunctionByName("ImageColorInvert"); + core.addApiFunctionByName("ImageColorGrayscale"); + core.addApiFunctionByName("ImageColorContrast"); + core.addApiFunctionByName("ImageColorBrightness"); + core.addApiFunctionByName("ImageColorReplace"); + //core.addApiFunctionByName("LoadImageColors") + //core.addApiFunctionByName("LoadImagePalette") + //core.addApiFunctionByName("UnloadImageColors") + //core.addApiFunctionByName("UnloadImagePalette") core.addApiFunctionByName("GetImageAlphaBorder"); core.addApiFunctionByName("GetImageColor"); // Image drawing functions - // core.addApiFunctionByName("ImageClearBackground") - // core.addApiFunctionByName("ImageDrawPixel") - // core.addApiFunctionByName("ImageDrawPixelV") - // core.addApiFunctionByName("ImageDrawLine") - // core.addApiFunctionByName("ImageDrawLineV") - // core.addApiFunctionByName("ImageDrawCircle") - // core.addApiFunctionByName("ImageDrawCircleV") - // core.addApiFunctionByName("ImageDrawCircleLines") - // core.addApiFunctionByName("ImageDrawCircleLinesV") - // core.addApiFunctionByName("ImageDrawRectangle") - // core.addApiFunctionByName("ImageDrawRectangleV") - // core.addApiFunctionByName("ImageDrawRectangleRec") - // core.addApiFunctionByName("ImageDrawRectangleLines") - // core.addApiFunctionByName("ImageDraw") - // core.addApiFunctionByName("ImageDrawText") - // core.addApiFunctionByName("ImageDrawTextEx") + core.addApiFunctionByName("ImageClearBackground"); + core.addApiFunctionByName("ImageDrawPixel"); + core.addApiFunctionByName("ImageDrawPixelV"); + core.addApiFunctionByName("ImageDrawLine"); + core.addApiFunctionByName("ImageDrawLineV"); + core.addApiFunctionByName("ImageDrawCircle"); + core.addApiFunctionByName("ImageDrawCircleV"); + core.addApiFunctionByName("ImageDrawCircleLines"); + core.addApiFunctionByName("ImageDrawCircleLinesV"); + core.addApiFunctionByName("ImageDrawRectangle"); + core.addApiFunctionByName("ImageDrawRectangleV"); + core.addApiFunctionByName("ImageDrawRectangleRec"); + core.addApiFunctionByName("ImageDrawRectangleLines"); + core.addApiFunctionByName("ImageDraw"); + core.addApiFunctionByName("ImageDrawText"); + core.addApiFunctionByName("ImageDrawTextEx"); // Texture loading functions core.addApiFunctionByName("LoadTexture"); core.addApiFunctionByName("LoadTextureFromImage"); @@ -1309,7 +1312,7 @@ function main() { // core.addApiFunctionByName("UpdateTexture") // core.addApiFunctionByName("UpdateTextureRec") // Texture configuration functions - // core.addApiFunctionByName("GenTextureMipmaps") + core.addApiFunctionByName("GenTextureMipmaps"); core.addApiFunctionByName("SetTextureFilter"); core.addApiFunctionByName("SetTextureWrap"); // Texture drawing functions @@ -1373,22 +1376,7 @@ function main() { // core.addApiFunctionByName("GetCodepointPrevious") // core.addApiFunctionByName("CodepointToUTF8") // Text strings management functions (no UTF-8 strings, only byte chars) - // Probably not needed - // core.addApiFunctionByName("TextCopy") - // core.addApiFunctionByName("TextIsEqual") - // core.addApiFunctionByName("TextLength") - // core.addApiFunctionByName("TextFormat") - // core.addApiFunctionByName("TextSubtext") - // core.addApiFunctionByName("TextReplace") - // core.addApiFunctionByName("TextInsert") - // core.addApiFunctionByName("TextJoin") - // core.addApiFunctionByName("TextSplit") - // core.addApiFunctionByName("TextAppend") - // core.addApiFunctionByName("TextFindIndex") - // core.addApiFunctionByName("TextToUpper") - // core.addApiFunctionByName("TextToLower") - // core.addApiFunctionByName("TextToPascal") - // core.addApiFunctionByName("TextToInteger") + // Not supported, use JS Stdlib instead // module: rmodels // Basic geometric 3D shapes drawing functions core.addApiFunctionByName("DrawLine3D"); @@ -1428,14 +1416,15 @@ function main() { core.addApiFunctionByName("DrawBillboardRec"); core.addApiFunctionByName("DrawBillboardPro"); // Mesh management functions - // core.addApiFunctionByName("UploadMesh") + // TODO: Refcounting needed? + core.addApiFunctionByName("UploadMesh"); // core.addApiFunctionByName("UpdateMeshBuffer") // "UnloadMesh" called by finalizer //core.addApiFunctionByName("DrawMesh") // core.addApiFunctionByName("DrawMeshInstanced") core.addApiFunctionByName("ExportMesh"); core.addApiFunctionByName("GetMeshBoundingBox"); - // core.addApiFunctionByName("GenMeshTangents") + core.addApiFunctionByName("GenMeshTangents"); // Mesh generation functions core.addApiFunctionByName("GenMeshPoly"); core.addApiFunctionByName("GenMeshPlane"); @@ -1498,8 +1487,8 @@ function main() { core.addApiFunctionByName("SetSoundPitch"); core.addApiFunctionByName("SetSoundPan"); core.addApiFunctionByName("WaveCopy"); - // core.addApiFunctionByName("WaveCrop") - // core.addApiFunctionByName("WaveFormat") + core.addApiFunctionByName("WaveCrop"); + core.addApiFunctionByName("WaveFormat"); // core.addApiFunctionByName("LoadWaveSamples") // core.addApiFunctionByName("UnloadWaveSamples") // Music management functions @@ -1577,81 +1566,81 @@ function main() { core.addApiFunctionByName("Vector3One"); core.addApiFunctionByName("Vector3Add"); core.addApiFunctionByName("Vector3AddValue"); - // core.addApiFunctionByName("Vector3Subtract") - // core.addApiFunctionByName("Vector3SubtractValue") - // core.addApiFunctionByName("Vector3Scale") - // core.addApiFunctionByName("Vector3Multiply") - // core.addApiFunctionByName("Vector3CrossProduct") - // core.addApiFunctionByName("Vector3Perpendicular") - // core.addApiFunctionByName("Vector3Length") - // core.addApiFunctionByName("Vector3LengthSqr") - // core.addApiFunctionByName("Vector3DotProduct") - // core.addApiFunctionByName("Vector3Distance") - // core.addApiFunctionByName("Vector3DistanceSqr") - // core.addApiFunctionByName("Vector3Angle") - // core.addApiFunctionByName("Vector3Negate") - // core.addApiFunctionByName("Vector3Divide") - // core.addApiFunctionByName("Vector3Normalize") - // core.addApiFunctionByName("Vector3OrthoNormalize") - // core.addApiFunctionByName("Vector3Transform") - // core.addApiFunctionByName("Vector3RotateByQuaternion") - // core.addApiFunctionByName("Vector3RotateByAxisAngle") - // core.addApiFunctionByName("Vector3Lerp") - // core.addApiFunctionByName("Vector3Reflect") - // core.addApiFunctionByName("Vector3Min") - // core.addApiFunctionByName("Vector3Max") - // core.addApiFunctionByName("Vector3Barycenter") - // core.addApiFunctionByName("Vector3Unproject") - // core.addApiFunctionByName("Vector3ToFloatV") - // core.addApiFunctionByName("Vector3Invert") - // core.addApiFunctionByName("Vector3Clamp") - // core.addApiFunctionByName("Vector3ClampValue") - // core.addApiFunctionByName("Vector3Equals") - // core.addApiFunctionByName("Vector3Refract") - // core.addApiFunctionByName("MatrixDeterminant") - // core.addApiFunctionByName("MatrixTrace") - // core.addApiFunctionByName("MatrixTranspose") - // core.addApiFunctionByName("MatrixInvert") - // core.addApiFunctionByName("MatrixIdentity") - // core.addApiFunctionByName("MatrixAdd") - // core.addApiFunctionByName("MatrixSubtract") - // core.addApiFunctionByName("MatrixMultiply") - // core.addApiFunctionByName("MatrixTranslate") - // core.addApiFunctionByName("MatrixRotate") - // core.addApiFunctionByName("MatrixRotateX") - // core.addApiFunctionByName("MatrixRotateY") - // core.addApiFunctionByName("MatrixRotateZ") - // core.addApiFunctionByName("MatrixRotateXYZ") - // core.addApiFunctionByName("MatrixRotateZYX") - // core.addApiFunctionByName("MatrixScale") - // core.addApiFunctionByName("MatrixFrustum") - // core.addApiFunctionByName("MatrixPerspective") - // core.addApiFunctionByName("MatrixOrtho") - // core.addApiFunctionByName("MatrixLookAt") - // core.addApiFunctionByName("MatrixToFloatV") - // core.addApiFunctionByName("QuaternionAdd") - // core.addApiFunctionByName("QuaternionAddValue") - // core.addApiFunctionByName("QuaternionSubtract") - // core.addApiFunctionByName("QuaternionSubtractValue") - // core.addApiFunctionByName("QuaternionIdentity") - // core.addApiFunctionByName("QuaternionLength") - // core.addApiFunctionByName("QuaternionNormalize") - // core.addApiFunctionByName("QuaternionInvert") - // core.addApiFunctionByName("QuaternionMultiply") - // core.addApiFunctionByName("QuaternionScale") - // core.addApiFunctionByName("QuaternionDivide") - // core.addApiFunctionByName("QuaternionLerp") - // core.addApiFunctionByName("QuaternionNlerp") - // core.addApiFunctionByName("QuaternionSlerp") - // core.addApiFunctionByName("QuaternionFromVector3ToVector3") - // core.addApiFunctionByName("QuaternionFromMatrix") - // core.addApiFunctionByName("QuaternionToMatrix") - // core.addApiFunctionByName("QuaternionFromAxisAngle") - // core.addApiFunctionByName("QuaternionToAxisAngle") - // core.addApiFunctionByName("QuaternionFromEuler") - // core.addApiFunctionByName("QuaternionToEuler") - // core.addApiFunctionByName("QuaternionTransform") - // core.addApiFunctionByName("QuaternionEquals") + core.addApiFunctionByName("Vector3Subtract"); + core.addApiFunctionByName("Vector3SubtractValue"); + core.addApiFunctionByName("Vector3Scale"); + core.addApiFunctionByName("Vector3Multiply"); + core.addApiFunctionByName("Vector3CrossProduct"); + core.addApiFunctionByName("Vector3Perpendicular"); + core.addApiFunctionByName("Vector3Length"); + core.addApiFunctionByName("Vector3LengthSqr"); + core.addApiFunctionByName("Vector3DotProduct"); + core.addApiFunctionByName("Vector3Distance"); + core.addApiFunctionByName("Vector3DistanceSqr"); + core.addApiFunctionByName("Vector3Angle"); + core.addApiFunctionByName("Vector3Negate"); + core.addApiFunctionByName("Vector3Divide"); + core.addApiFunctionByName("Vector3Normalize"); + //core.addApiFunctionByName("Vector3OrthoNormalize") + core.addApiFunctionByName("Vector3Transform"); + core.addApiFunctionByName("Vector3RotateByQuaternion"); + core.addApiFunctionByName("Vector3RotateByAxisAngle"); + core.addApiFunctionByName("Vector3Lerp"); + core.addApiFunctionByName("Vector3Reflect"); + core.addApiFunctionByName("Vector3Min"); + core.addApiFunctionByName("Vector3Max"); + core.addApiFunctionByName("Vector3Barycenter"); + core.addApiFunctionByName("Vector3Unproject"); + //core.addApiFunctionByName("Vector3ToFloatV") + core.addApiFunctionByName("Vector3Invert"); + core.addApiFunctionByName("Vector3Clamp"); + core.addApiFunctionByName("Vector3ClampValue"); + core.addApiFunctionByName("Vector3Equals"); + core.addApiFunctionByName("Vector3Refract"); + core.addApiFunctionByName("MatrixDeterminant"); + core.addApiFunctionByName("MatrixTrace"); + core.addApiFunctionByName("MatrixTranspose"); + core.addApiFunctionByName("MatrixInvert"); + core.addApiFunctionByName("MatrixIdentity"); + core.addApiFunctionByName("MatrixAdd"); + core.addApiFunctionByName("MatrixSubtract"); + core.addApiFunctionByName("MatrixMultiply"); + core.addApiFunctionByName("MatrixTranslate"); + core.addApiFunctionByName("MatrixRotate"); + core.addApiFunctionByName("MatrixRotateX"); + core.addApiFunctionByName("MatrixRotateY"); + core.addApiFunctionByName("MatrixRotateZ"); + core.addApiFunctionByName("MatrixRotateXYZ"); + core.addApiFunctionByName("MatrixRotateZYX"); + core.addApiFunctionByName("MatrixScale"); + core.addApiFunctionByName("MatrixFrustum"); + core.addApiFunctionByName("MatrixPerspective"); + core.addApiFunctionByName("MatrixOrtho"); + core.addApiFunctionByName("MatrixLookAt"); + //core.addApiFunctionByName("MatrixToFloatV") + core.addApiFunctionByName("QuaternionAdd"); + core.addApiFunctionByName("QuaternionAddValue"); + core.addApiFunctionByName("QuaternionSubtract"); + core.addApiFunctionByName("QuaternionSubtractValue"); + core.addApiFunctionByName("QuaternionIdentity"); + core.addApiFunctionByName("QuaternionLength"); + core.addApiFunctionByName("QuaternionNormalize"); + core.addApiFunctionByName("QuaternionInvert"); + core.addApiFunctionByName("QuaternionMultiply"); + core.addApiFunctionByName("QuaternionScale"); + core.addApiFunctionByName("QuaternionDivide"); + core.addApiFunctionByName("QuaternionLerp"); + core.addApiFunctionByName("QuaternionNlerp"); + core.addApiFunctionByName("QuaternionSlerp"); + core.addApiFunctionByName("QuaternionFromVector3ToVector3"); + core.addApiFunctionByName("QuaternionFromMatrix"); + core.addApiFunctionByName("QuaternionToMatrix"); + core.addApiFunctionByName("QuaternionFromAxisAngle"); + //core.addApiFunctionByName("QuaternionToAxisAngle") + core.addApiFunctionByName("QuaternionFromEuler"); + core.addApiFunctionByName("QuaternionToEuler"); + core.addApiFunctionByName("QuaternionTransform"); + core.addApiFunctionByName("QuaternionEquals"); api.defines.filter(x => x.type === "COLOR").map(x => ({ name: x.name, description: x.description, values: (x.value.match(/\{([^}]+)\}/) || "")[1].split(',').map(x => x.trim()) })).forEach(x => { core.exportGlobalStruct("Color", x.name, x.values, x.description); }); @@ -1663,6 +1652,7 @@ function main() { api.enums.find(x => x.name === "MouseCursor")?.values.forEach(x => core.exportGlobalConstant(x.name, x.description)); api.enums.find(x => x.name === "PixelFormat")?.values.forEach(x => core.exportGlobalConstant(x.name, x.description)); api.enums.find(x => x.name === "CameraProjection")?.values.forEach(x => core.exportGlobalConstant(x.name, x.description)); + api.enums.find(x => x.name === "CameraMode")?.values.forEach(x => core.exportGlobalConstant(x.name, x.description)); core.writeTo("src/bindings/js_raylib_core.h"); core.typings.writeTo("examples/lib.raylib.d.ts"); } diff --git a/src/bindings/js_raylib_core.h b/src/bindings/js_raylib_core.h index ce26077..a336095 100644 --- a/src/bindings/js_raylib_core.h +++ b/src/bindings/js_raylib_core.h @@ -1499,6 +1499,14 @@ static JSValue js_restoreWindow(JSContext * ctx, JSValueConst this_val, int argc return JS_UNDEFINED; } +static JSValue js_setWindowIcon(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image_ptr = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image_ptr == NULL) return JS_EXCEPTION; + Image image = *image_ptr; + SetWindowIcon(image); + return JS_UNDEFINED; +} + static JSValue js_setWindowTitle(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { const char * title = (const char *)JS_ToCString(ctx, argv[0]); if(title == NULL) return JS_EXCEPTION; @@ -1763,6 +1771,19 @@ static JSValue js_endMode3D(JSContext * ctx, JSValueConst this_val, int argc, JS return JS_UNDEFINED; } +static JSValue js_beginShaderMode(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Shader* shader_ptr = (Shader*)JS_GetOpaque2(ctx, argv[0], js_Shader_class_id); + if(shader_ptr == NULL) return JS_EXCEPTION; + Shader shader = *shader_ptr; + BeginShaderMode(shader); + return JS_UNDEFINED; +} + +static JSValue js_endShaderMode(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + EndShaderMode(); + return JS_UNDEFINED; +} + static JSValue js_beginBlendMode(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { int mode; JS_ToInt32(ctx, &mode, argv[0]); @@ -1793,6 +1814,107 @@ static JSValue js_endScissorMode(JSContext * ctx, JSValueConst this_val, int arg return JS_UNDEFINED; } +static JSValue js_loadShader(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + const char * vsFileName = (const char *)JS_ToCString(ctx, argv[0]); + if(vsFileName == NULL) return JS_EXCEPTION; + const char * fsFileName = (const char *)JS_ToCString(ctx, argv[1]); + if(fsFileName == NULL) return JS_EXCEPTION; + Shader returnVal = LoadShader(vsFileName, fsFileName); + JS_FreeCString(ctx, vsFileName); + JS_FreeCString(ctx, fsFileName); + Shader* ret_ptr = (Shader*)js_malloc(ctx, sizeof(Shader)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Shader_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_isShaderReady(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Shader* shader_ptr = (Shader*)JS_GetOpaque2(ctx, argv[0], js_Shader_class_id); + if(shader_ptr == NULL) return JS_EXCEPTION; + Shader shader = *shader_ptr; + bool returnVal = IsShaderReady(shader); + JSValue ret = JS_NewBool(ctx, returnVal); + return ret; +} + +static JSValue js_getShaderLocation(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Shader* shader_ptr = (Shader*)JS_GetOpaque2(ctx, argv[0], js_Shader_class_id); + if(shader_ptr == NULL) return JS_EXCEPTION; + Shader shader = *shader_ptr; + const char * uniformName = (const char *)JS_ToCString(ctx, argv[1]); + if(uniformName == NULL) return JS_EXCEPTION; + int returnVal = GetShaderLocation(shader, uniformName); + JS_FreeCString(ctx, uniformName); + JSValue ret = JS_NewInt32(ctx, returnVal); + return ret; +} + +static JSValue js_getShaderLocationAttrib(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Shader* shader_ptr = (Shader*)JS_GetOpaque2(ctx, argv[0], js_Shader_class_id); + if(shader_ptr == NULL) return JS_EXCEPTION; + Shader shader = *shader_ptr; + const char * attribName = (const char *)JS_ToCString(ctx, argv[1]); + if(attribName == NULL) return JS_EXCEPTION; + int returnVal = GetShaderLocationAttrib(shader, attribName); + JS_FreeCString(ctx, attribName); + JSValue ret = JS_NewInt32(ctx, returnVal); + return ret; +} + +static JSValue js_setShaderValueMatrix(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Shader* shader_ptr = (Shader*)JS_GetOpaque2(ctx, argv[0], js_Shader_class_id); + if(shader_ptr == NULL) return JS_EXCEPTION; + Shader shader = *shader_ptr; + int locIndex; + JS_ToInt32(ctx, &locIndex, argv[1]); + Matrix* mat_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[2], js_Matrix_class_id); + if(mat_ptr == NULL) return JS_EXCEPTION; + Matrix mat = *mat_ptr; + SetShaderValueMatrix(shader, locIndex, mat); + return JS_UNDEFINED; +} + +static JSValue js_setShaderValueTexture(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Shader* shader_ptr = (Shader*)JS_GetOpaque2(ctx, argv[0], js_Shader_class_id); + if(shader_ptr == NULL) return JS_EXCEPTION; + Shader shader = *shader_ptr; + int locIndex; + JS_ToInt32(ctx, &locIndex, argv[1]); + Texture2D* texture_ptr = (Texture2D*)JS_GetOpaque2(ctx, argv[2], js_Texture_class_id); + if(texture_ptr == NULL) return JS_EXCEPTION; + Texture2D texture = *texture_ptr; + SetShaderValueTexture(shader, locIndex, texture); + return JS_UNDEFINED; +} + +static JSValue js_getMouseRay(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector2* mousePosition_ptr = (Vector2*)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + if(mousePosition_ptr == NULL) return JS_EXCEPTION; + Vector2 mousePosition = *mousePosition_ptr; + Camera* camera_ptr = (Camera*)JS_GetOpaque2(ctx, argv[1], js_Camera3D_class_id); + if(camera_ptr == NULL) return JS_EXCEPTION; + Camera camera = *camera_ptr; + Ray returnVal = GetMouseRay(mousePosition, camera); + Ray* ret_ptr = (Ray*)js_malloc(ctx, sizeof(Ray)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Ray_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_getCameraMatrix(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Camera* camera_ptr = (Camera*)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + if(camera_ptr == NULL) return JS_EXCEPTION; + Camera camera = *camera_ptr; + Matrix returnVal = GetCameraMatrix(camera); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + static JSValue js_getCameraMatrix2D(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { Camera2D* camera_ptr = (Camera2D*)JS_GetOpaque2(ctx, argv[0], js_Camera2D_class_id); if(camera_ptr == NULL) return JS_EXCEPTION; @@ -1805,6 +1927,21 @@ static JSValue js_getCameraMatrix2D(JSContext * ctx, JSValueConst this_val, int return ret; } +static JSValue js_getWorldToScreen(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* position_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(position_ptr == NULL) return JS_EXCEPTION; + Vector3 position = *position_ptr; + Camera* camera_ptr = (Camera*)JS_GetOpaque2(ctx, argv[1], js_Camera3D_class_id); + if(camera_ptr == NULL) return JS_EXCEPTION; + Camera camera = *camera_ptr; + Vector2 returnVal = GetWorldToScreen(position, camera); + Vector2* ret_ptr = (Vector2*)js_malloc(ctx, sizeof(Vector2)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + static JSValue js_getScreenToWorld2D(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { Vector2* position_ptr = (Vector2*)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); if(position_ptr == NULL) return JS_EXCEPTION; @@ -1820,6 +1957,25 @@ static JSValue js_getScreenToWorld2D(JSContext * ctx, JSValueConst this_val, int return ret; } +static JSValue js_getWorldToScreenEx(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* position_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(position_ptr == NULL) return JS_EXCEPTION; + Vector3 position = *position_ptr; + Camera* camera_ptr = (Camera*)JS_GetOpaque2(ctx, argv[1], js_Camera3D_class_id); + if(camera_ptr == NULL) return JS_EXCEPTION; + Camera camera = *camera_ptr; + int width; + JS_ToInt32(ctx, &width, argv[2]); + int height; + JS_ToInt32(ctx, &height, argv[3]); + Vector2 returnVal = GetWorldToScreenEx(position, camera, width, height); + Vector2* ret_ptr = (Vector2*)js_malloc(ctx, sizeof(Vector2)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + static JSValue js_getWorldToScreen2D(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { Vector2* position_ptr = (Vector2*)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); if(position_ptr == NULL) return JS_EXCEPTION; @@ -2414,6 +2570,31 @@ static JSValue js_getGesturePinchAngle(JSContext * ctx, JSValueConst this_val, i return ret; } +static JSValue js_updateCamera(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Camera* camera = (Camera*)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + if(camera == NULL) return JS_EXCEPTION; + int mode; + JS_ToInt32(ctx, &mode, argv[1]); + UpdateCamera(camera, mode); + return JS_UNDEFINED; +} + +static JSValue js_updateCameraPro(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Camera* camera = (Camera*)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + if(camera == NULL) return JS_EXCEPTION; + Vector3* movement_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(movement_ptr == NULL) return JS_EXCEPTION; + Vector3 movement = *movement_ptr; + Vector3* rotation_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + if(rotation_ptr == NULL) return JS_EXCEPTION; + Vector3 rotation = *rotation_ptr; + double _double_zoom; + JS_ToFloat64(ctx, &_double_zoom, argv[3]); + float zoom = (float)_double_zoom; + UpdateCameraPro(camera, movement, rotation, zoom); + return JS_UNDEFINED; +} + static JSValue js_drawPixel(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { int posX; JS_ToInt32(ctx, &posX, argv[0]); @@ -3417,6 +3598,254 @@ static JSValue js_imageText(JSContext * ctx, JSValueConst this_val, int argc, JS return ret; } +static JSValue js_imageTextEx(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Font* font_ptr = (Font*)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); + if(font_ptr == NULL) return JS_EXCEPTION; + Font font = *font_ptr; + const char * text = (const char *)JS_ToCString(ctx, argv[1]); + if(text == NULL) return JS_EXCEPTION; + double _double_fontSize; + JS_ToFloat64(ctx, &_double_fontSize, argv[2]); + float fontSize = (float)_double_fontSize; + double _double_spacing; + JS_ToFloat64(ctx, &_double_spacing, argv[3]); + float spacing = (float)_double_spacing; + Color* tint_ptr = (Color*)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + if(tint_ptr == NULL) return JS_EXCEPTION; + Color tint = *tint_ptr; + Image returnVal = ImageTextEx(font, text, fontSize, spacing, tint); + JS_FreeCString(ctx, text); + Image* ret_ptr = (Image*)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_imageFormat(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + int newFormat; + JS_ToInt32(ctx, &newFormat, argv[1]); + ImageFormat(image, newFormat); + return JS_UNDEFINED; +} + +static JSValue js_imageToPOT(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + Color* fill_ptr = (Color*)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + if(fill_ptr == NULL) return JS_EXCEPTION; + Color fill = *fill_ptr; + ImageToPOT(image, fill); + return JS_UNDEFINED; +} + +static JSValue js_imageCrop(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + Rectangle* crop_ptr = (Rectangle*)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); + if(crop_ptr == NULL) return JS_EXCEPTION; + Rectangle crop = *crop_ptr; + ImageCrop(image, crop); + return JS_UNDEFINED; +} + +static JSValue js_imageAlphaCrop(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + double _double_threshold; + JS_ToFloat64(ctx, &_double_threshold, argv[1]); + float threshold = (float)_double_threshold; + ImageAlphaCrop(image, threshold); + return JS_UNDEFINED; +} + +static JSValue js_imageAlphaClear(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + double _double_threshold; + JS_ToFloat64(ctx, &_double_threshold, argv[2]); + float threshold = (float)_double_threshold; + ImageAlphaClear(image, color, threshold); + return JS_UNDEFINED; +} + +static JSValue js_imageAlphaMask(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + Image* alphaMask_ptr = (Image*)JS_GetOpaque2(ctx, argv[1], js_Image_class_id); + if(alphaMask_ptr == NULL) return JS_EXCEPTION; + Image alphaMask = *alphaMask_ptr; + ImageAlphaMask(image, alphaMask); + return JS_UNDEFINED; +} + +static JSValue js_imageAlphaPremultiply(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + ImageAlphaPremultiply(image); + return JS_UNDEFINED; +} + +static JSValue js_imageBlurGaussian(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + int blurSize; + JS_ToInt32(ctx, &blurSize, argv[1]); + ImageBlurGaussian(image, blurSize); + return JS_UNDEFINED; +} + +static JSValue js_imageResize(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + int newWidth; + JS_ToInt32(ctx, &newWidth, argv[1]); + int newHeight; + JS_ToInt32(ctx, &newHeight, argv[2]); + ImageResize(image, newWidth, newHeight); + return JS_UNDEFINED; +} + +static JSValue js_imageResizeNN(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + int newWidth; + JS_ToInt32(ctx, &newWidth, argv[1]); + int newHeight; + JS_ToInt32(ctx, &newHeight, argv[2]); + ImageResizeNN(image, newWidth, newHeight); + return JS_UNDEFINED; +} + +static JSValue js_imageResizeCanvas(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + int newWidth; + JS_ToInt32(ctx, &newWidth, argv[1]); + int newHeight; + JS_ToInt32(ctx, &newHeight, argv[2]); + int offsetX; + JS_ToInt32(ctx, &offsetX, argv[3]); + int offsetY; + JS_ToInt32(ctx, &offsetY, argv[4]); + Color* fill_ptr = (Color*)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + if(fill_ptr == NULL) return JS_EXCEPTION; + Color fill = *fill_ptr; + ImageResizeCanvas(image, newWidth, newHeight, offsetX, offsetY, fill); + return JS_UNDEFINED; +} + +static JSValue js_imageMipmaps(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + ImageMipmaps(image); + return JS_UNDEFINED; +} + +static JSValue js_imageDither(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + int rBpp; + JS_ToInt32(ctx, &rBpp, argv[1]); + int gBpp; + JS_ToInt32(ctx, &gBpp, argv[2]); + int bBpp; + JS_ToInt32(ctx, &bBpp, argv[3]); + int aBpp; + JS_ToInt32(ctx, &aBpp, argv[4]); + ImageDither(image, rBpp, gBpp, bBpp, aBpp); + return JS_UNDEFINED; +} + +static JSValue js_imageFlipVertical(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + ImageFlipVertical(image); + return JS_UNDEFINED; +} + +static JSValue js_imageFlipHorizontal(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + ImageFlipHorizontal(image); + return JS_UNDEFINED; +} + +static JSValue js_imageRotateCW(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + ImageRotateCW(image); + return JS_UNDEFINED; +} + +static JSValue js_imageRotateCCW(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + ImageRotateCCW(image); + return JS_UNDEFINED; +} + +static JSValue js_imageColorTint(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageColorTint(image, color); + return JS_UNDEFINED; +} + +static JSValue js_imageColorInvert(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + ImageColorInvert(image); + return JS_UNDEFINED; +} + +static JSValue js_imageColorGrayscale(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + ImageColorGrayscale(image); + return JS_UNDEFINED; +} + +static JSValue js_imageColorContrast(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + double _double_contrast; + JS_ToFloat64(ctx, &_double_contrast, argv[1]); + float contrast = (float)_double_contrast; + ImageColorContrast(image, contrast); + return JS_UNDEFINED; +} + +static JSValue js_imageColorBrightness(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + int brightness; + JS_ToInt32(ctx, &brightness, argv[1]); + ImageColorBrightness(image, brightness); + return JS_UNDEFINED; +} + +static JSValue js_imageColorReplace(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* image = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(image == NULL) return JS_EXCEPTION; + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + Color* replace_ptr = (Color*)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + if(replace_ptr == NULL) return JS_EXCEPTION; + Color replace = *replace_ptr; + ImageColorReplace(image, color, replace); + return JS_UNDEFINED; +} + static JSValue js_getImageAlphaBorder(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { Image* image_ptr = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); if(image_ptr == NULL) return JS_EXCEPTION; @@ -3448,6 +3877,264 @@ static JSValue js_getImageColor(JSContext * ctx, JSValueConst this_val, int argc return ret; } +static JSValue js_imageClearBackground(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageClearBackground(dst, color); + return JS_UNDEFINED; +} + +static JSValue js_imageDrawPixel(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + int posX; + JS_ToInt32(ctx, &posX, argv[1]); + int posY; + JS_ToInt32(ctx, &posY, argv[2]); + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageDrawPixel(dst, posX, posY, color); + return JS_UNDEFINED; +} + +static JSValue js_imageDrawPixelV(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + Vector2* position_ptr = (Vector2*)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + if(position_ptr == NULL) return JS_EXCEPTION; + Vector2 position = *position_ptr; + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageDrawPixelV(dst, position, color); + return JS_UNDEFINED; +} + +static JSValue js_imageDrawLine(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + int startPosX; + JS_ToInt32(ctx, &startPosX, argv[1]); + int startPosY; + JS_ToInt32(ctx, &startPosY, argv[2]); + int endPosX; + JS_ToInt32(ctx, &endPosX, argv[3]); + int endPosY; + JS_ToInt32(ctx, &endPosY, argv[4]); + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageDrawLine(dst, startPosX, startPosY, endPosX, endPosY, color); + return JS_UNDEFINED; +} + +static JSValue js_imageDrawLineV(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + Vector2* start_ptr = (Vector2*)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + if(start_ptr == NULL) return JS_EXCEPTION; + Vector2 start = *start_ptr; + Vector2* end_ptr = (Vector2*)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + if(end_ptr == NULL) return JS_EXCEPTION; + Vector2 end = *end_ptr; + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageDrawLineV(dst, start, end, color); + return JS_UNDEFINED; +} + +static JSValue js_imageDrawCircle(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + int centerX; + JS_ToInt32(ctx, ¢erX, argv[1]); + int centerY; + JS_ToInt32(ctx, ¢erY, argv[2]); + int radius; + JS_ToInt32(ctx, &radius, argv[3]); + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageDrawCircle(dst, centerX, centerY, radius, color); + return JS_UNDEFINED; +} + +static JSValue js_imageDrawCircleV(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + Vector2* center_ptr = (Vector2*)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + if(center_ptr == NULL) return JS_EXCEPTION; + Vector2 center = *center_ptr; + int radius; + JS_ToInt32(ctx, &radius, argv[2]); + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageDrawCircleV(dst, center, radius, color); + return JS_UNDEFINED; +} + +static JSValue js_imageDrawCircleLines(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + int centerX; + JS_ToInt32(ctx, ¢erX, argv[1]); + int centerY; + JS_ToInt32(ctx, ¢erY, argv[2]); + int radius; + JS_ToInt32(ctx, &radius, argv[3]); + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageDrawCircleLines(dst, centerX, centerY, radius, color); + return JS_UNDEFINED; +} + +static JSValue js_imageDrawCircleLinesV(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + Vector2* center_ptr = (Vector2*)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + if(center_ptr == NULL) return JS_EXCEPTION; + Vector2 center = *center_ptr; + int radius; + JS_ToInt32(ctx, &radius, argv[2]); + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageDrawCircleLinesV(dst, center, radius, color); + return JS_UNDEFINED; +} + +static JSValue js_imageDrawRectangle(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + int posX; + JS_ToInt32(ctx, &posX, argv[1]); + int posY; + JS_ToInt32(ctx, &posY, argv[2]); + int width; + JS_ToInt32(ctx, &width, argv[3]); + int height; + JS_ToInt32(ctx, &height, argv[4]); + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageDrawRectangle(dst, posX, posY, width, height, color); + return JS_UNDEFINED; +} + +static JSValue js_imageDrawRectangleV(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + Vector2* position_ptr = (Vector2*)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + if(position_ptr == NULL) return JS_EXCEPTION; + Vector2 position = *position_ptr; + Vector2* size_ptr = (Vector2*)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + if(size_ptr == NULL) return JS_EXCEPTION; + Vector2 size = *size_ptr; + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageDrawRectangleV(dst, position, size, color); + return JS_UNDEFINED; +} + +static JSValue js_imageDrawRectangleRec(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + Rectangle* rec_ptr = (Rectangle*)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); + if(rec_ptr == NULL) return JS_EXCEPTION; + Rectangle rec = *rec_ptr; + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageDrawRectangleRec(dst, rec, color); + return JS_UNDEFINED; +} + +static JSValue js_imageDrawRectangleLines(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + Rectangle* rec_ptr = (Rectangle*)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); + if(rec_ptr == NULL) return JS_EXCEPTION; + Rectangle rec = *rec_ptr; + int thick; + JS_ToInt32(ctx, &thick, argv[2]); + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageDrawRectangleLines(dst, rec, thick, color); + return JS_UNDEFINED; +} + +static JSValue js_imageDraw(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + Image* src_ptr = (Image*)JS_GetOpaque2(ctx, argv[1], js_Image_class_id); + if(src_ptr == NULL) return JS_EXCEPTION; + Image src = *src_ptr; + Rectangle* srcRec_ptr = (Rectangle*)JS_GetOpaque2(ctx, argv[2], js_Rectangle_class_id); + if(srcRec_ptr == NULL) return JS_EXCEPTION; + Rectangle srcRec = *srcRec_ptr; + Rectangle* dstRec_ptr = (Rectangle*)JS_GetOpaque2(ctx, argv[3], js_Rectangle_class_id); + if(dstRec_ptr == NULL) return JS_EXCEPTION; + Rectangle dstRec = *dstRec_ptr; + Color* tint_ptr = (Color*)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + if(tint_ptr == NULL) return JS_EXCEPTION; + Color tint = *tint_ptr; + ImageDraw(dst, src, srcRec, dstRec, tint); + return JS_UNDEFINED; +} + +static JSValue js_imageDrawText(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + const char * text = (const char *)JS_ToCString(ctx, argv[1]); + if(text == NULL) return JS_EXCEPTION; + int posX; + JS_ToInt32(ctx, &posX, argv[2]); + int posY; + JS_ToInt32(ctx, &posY, argv[3]); + int fontSize; + JS_ToInt32(ctx, &fontSize, argv[4]); + Color* color_ptr = (Color*)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + if(color_ptr == NULL) return JS_EXCEPTION; + Color color = *color_ptr; + ImageDrawText(dst, text, posX, posY, fontSize, color); + JS_FreeCString(ctx, text); + return JS_UNDEFINED; +} + +static JSValue js_imageDrawTextEx(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Image* dst = (Image*)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if(dst == NULL) return JS_EXCEPTION; + Font* font_ptr = (Font*)JS_GetOpaque2(ctx, argv[1], js_Font_class_id); + if(font_ptr == NULL) return JS_EXCEPTION; + Font font = *font_ptr; + const char * text = (const char *)JS_ToCString(ctx, argv[2]); + if(text == NULL) return JS_EXCEPTION; + Vector2* position_ptr = (Vector2*)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); + if(position_ptr == NULL) return JS_EXCEPTION; + Vector2 position = *position_ptr; + double _double_fontSize; + JS_ToFloat64(ctx, &_double_fontSize, argv[4]); + float fontSize = (float)_double_fontSize; + double _double_spacing; + JS_ToFloat64(ctx, &_double_spacing, argv[5]); + float spacing = (float)_double_spacing; + Color* tint_ptr = (Color*)JS_GetOpaque2(ctx, argv[6], js_Color_class_id); + if(tint_ptr == NULL) return JS_EXCEPTION; + Color tint = *tint_ptr; + ImageDrawTextEx(dst, font, text, position, fontSize, spacing, tint); + JS_FreeCString(ctx, text); + return JS_UNDEFINED; +} + static JSValue js_loadTexture(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { const char * fileName = (const char *)JS_ToCString(ctx, argv[0]); if(fileName == NULL) return JS_EXCEPTION; @@ -3495,6 +4182,13 @@ static JSValue js_isTextureReady(JSContext * ctx, JSValueConst this_val, int arg return ret; } +static JSValue js_genTextureMipmaps(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Texture2D* texture = (Texture2D*)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + if(texture == NULL) return JS_EXCEPTION; + GenTextureMipmaps(texture); + return JS_UNDEFINED; +} + static JSValue js_setTextureFilter(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { Texture2D* texture_ptr = (Texture2D*)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); if(texture_ptr == NULL) return JS_EXCEPTION; @@ -4540,6 +5234,14 @@ static JSValue js_drawBillboardPro(JSContext * ctx, JSValueConst this_val, int a return JS_UNDEFINED; } +static JSValue js_uploadMesh(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Mesh* mesh = (Mesh*)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); + if(mesh == NULL) return JS_EXCEPTION; + bool dynamic = JS_ToBool(ctx, argv[1]); + UploadMesh(mesh, dynamic); + return JS_UNDEFINED; +} + static JSValue js_exportMesh(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { Mesh* mesh_ptr = (Mesh*)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); if(mesh_ptr == NULL) return JS_EXCEPTION; @@ -4564,6 +5266,13 @@ static JSValue js_getMeshBoundingBox(JSContext * ctx, JSValueConst this_val, int return ret; } +static JSValue js_genMeshTangents(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Mesh* mesh = (Mesh*)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); + if(mesh == NULL) return JS_EXCEPTION; + GenMeshTangents(mesh); + return JS_UNDEFINED; +} + static JSValue js_genMeshPoly(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { int sides; JS_ToInt32(ctx, &sides, argv[0]); @@ -5066,6 +5775,30 @@ static JSValue js_waveCopy(JSContext * ctx, JSValueConst this_val, int argc, JSV return ret; } +static JSValue js_waveCrop(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Wave* wave = (Wave*)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); + if(wave == NULL) return JS_EXCEPTION; + int initSample; + JS_ToInt32(ctx, &initSample, argv[1]); + int finalSample; + JS_ToInt32(ctx, &finalSample, argv[2]); + WaveCrop(wave, initSample, finalSample); + return JS_UNDEFINED; +} + +static JSValue js_waveFormat(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Wave* wave = (Wave*)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); + if(wave == NULL) return JS_EXCEPTION; + int sampleRate; + JS_ToInt32(ctx, &sampleRate, argv[1]); + int sampleSize; + JS_ToInt32(ctx, &sampleSize, argv[2]); + int channels; + JS_ToInt32(ctx, &channels, argv[3]); + WaveFormat(wave, sampleRate, sampleSize, channels); + return JS_UNDEFINED; +} + static JSValue js_loadMusicStream(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { const char * fileName = (const char *)JS_ToCString(ctx, argv[0]); if(fileName == NULL) return JS_EXCEPTION; @@ -5705,6 +6438,1022 @@ static JSValue js_vector3AddValue(JSContext * ctx, JSValueConst this_val, int ar return ret; } +static JSValue js_vector3Subtract(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v1_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v1_ptr == NULL) return JS_EXCEPTION; + Vector3 v1 = *v1_ptr; + Vector3* v2_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(v2_ptr == NULL) return JS_EXCEPTION; + Vector3 v2 = *v2_ptr; + Vector3 returnVal = Vector3Subtract(v1, v2); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3SubtractValue(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + Vector3 v = *v_ptr; + double _double_sub; + JS_ToFloat64(ctx, &_double_sub, argv[1]); + float sub = (float)_double_sub; + Vector3 returnVal = Vector3SubtractValue(v, sub); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Scale(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + Vector3 v = *v_ptr; + double _double_scalar; + JS_ToFloat64(ctx, &_double_scalar, argv[1]); + float scalar = (float)_double_scalar; + Vector3 returnVal = Vector3Scale(v, scalar); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Multiply(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v1_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v1_ptr == NULL) return JS_EXCEPTION; + Vector3 v1 = *v1_ptr; + Vector3* v2_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(v2_ptr == NULL) return JS_EXCEPTION; + Vector3 v2 = *v2_ptr; + Vector3 returnVal = Vector3Multiply(v1, v2); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3CrossProduct(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v1_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v1_ptr == NULL) return JS_EXCEPTION; + Vector3 v1 = *v1_ptr; + Vector3* v2_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(v2_ptr == NULL) return JS_EXCEPTION; + Vector3 v2 = *v2_ptr; + Vector3 returnVal = Vector3CrossProduct(v1, v2); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Perpendicular(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + Vector3 v = *v_ptr; + Vector3 returnVal = Vector3Perpendicular(v); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Length(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + const Vector3* v_ptr = (const Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + const Vector3 v = *v_ptr; + float returnVal = Vector3Length(v); + JSValue ret = JS_NewFloat64(ctx, returnVal); + return ret; +} + +static JSValue js_vector3LengthSqr(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + const Vector3* v_ptr = (const Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + const Vector3 v = *v_ptr; + float returnVal = Vector3LengthSqr(v); + JSValue ret = JS_NewFloat64(ctx, returnVal); + return ret; +} + +static JSValue js_vector3DotProduct(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v1_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v1_ptr == NULL) return JS_EXCEPTION; + Vector3 v1 = *v1_ptr; + Vector3* v2_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(v2_ptr == NULL) return JS_EXCEPTION; + Vector3 v2 = *v2_ptr; + float returnVal = Vector3DotProduct(v1, v2); + JSValue ret = JS_NewFloat64(ctx, returnVal); + return ret; +} + +static JSValue js_vector3Distance(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v1_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v1_ptr == NULL) return JS_EXCEPTION; + Vector3 v1 = *v1_ptr; + Vector3* v2_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(v2_ptr == NULL) return JS_EXCEPTION; + Vector3 v2 = *v2_ptr; + float returnVal = Vector3Distance(v1, v2); + JSValue ret = JS_NewFloat64(ctx, returnVal); + return ret; +} + +static JSValue js_vector3DistanceSqr(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v1_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v1_ptr == NULL) return JS_EXCEPTION; + Vector3 v1 = *v1_ptr; + Vector3* v2_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(v2_ptr == NULL) return JS_EXCEPTION; + Vector3 v2 = *v2_ptr; + float returnVal = Vector3DistanceSqr(v1, v2); + JSValue ret = JS_NewFloat64(ctx, returnVal); + return ret; +} + +static JSValue js_vector3Angle(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v1_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v1_ptr == NULL) return JS_EXCEPTION; + Vector3 v1 = *v1_ptr; + Vector3* v2_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(v2_ptr == NULL) return JS_EXCEPTION; + Vector3 v2 = *v2_ptr; + float returnVal = Vector3Angle(v1, v2); + JSValue ret = JS_NewFloat64(ctx, returnVal); + return ret; +} + +static JSValue js_vector3Negate(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + Vector3 v = *v_ptr; + Vector3 returnVal = Vector3Negate(v); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Divide(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v1_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v1_ptr == NULL) return JS_EXCEPTION; + Vector3 v1 = *v1_ptr; + Vector3* v2_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(v2_ptr == NULL) return JS_EXCEPTION; + Vector3 v2 = *v2_ptr; + Vector3 returnVal = Vector3Divide(v1, v2); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Normalize(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + Vector3 v = *v_ptr; + Vector3 returnVal = Vector3Normalize(v); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Transform(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + Vector3 v = *v_ptr; + Matrix* mat_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[1], js_Matrix_class_id); + if(mat_ptr == NULL) return JS_EXCEPTION; + Matrix mat = *mat_ptr; + Vector3 returnVal = Vector3Transform(v, mat); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3RotateByQuaternion(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + Vector3 v = *v_ptr; + Quaternion* q_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if(q_ptr == NULL) return JS_EXCEPTION; + Quaternion q = *q_ptr; + Vector3 returnVal = Vector3RotateByQuaternion(v, q); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3RotateByAxisAngle(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + Vector3 v = *v_ptr; + Vector3* axis_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(axis_ptr == NULL) return JS_EXCEPTION; + Vector3 axis = *axis_ptr; + double _double_angle; + JS_ToFloat64(ctx, &_double_angle, argv[2]); + float angle = (float)_double_angle; + Vector3 returnVal = Vector3RotateByAxisAngle(v, axis, angle); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Lerp(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v1_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v1_ptr == NULL) return JS_EXCEPTION; + Vector3 v1 = *v1_ptr; + Vector3* v2_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(v2_ptr == NULL) return JS_EXCEPTION; + Vector3 v2 = *v2_ptr; + double _double_amount; + JS_ToFloat64(ctx, &_double_amount, argv[2]); + float amount = (float)_double_amount; + Vector3 returnVal = Vector3Lerp(v1, v2, amount); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Reflect(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + Vector3 v = *v_ptr; + Vector3* normal_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(normal_ptr == NULL) return JS_EXCEPTION; + Vector3 normal = *normal_ptr; + Vector3 returnVal = Vector3Reflect(v, normal); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Min(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v1_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v1_ptr == NULL) return JS_EXCEPTION; + Vector3 v1 = *v1_ptr; + Vector3* v2_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(v2_ptr == NULL) return JS_EXCEPTION; + Vector3 v2 = *v2_ptr; + Vector3 returnVal = Vector3Min(v1, v2); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Max(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v1_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v1_ptr == NULL) return JS_EXCEPTION; + Vector3 v1 = *v1_ptr; + Vector3* v2_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(v2_ptr == NULL) return JS_EXCEPTION; + Vector3 v2 = *v2_ptr; + Vector3 returnVal = Vector3Max(v1, v2); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Barycenter(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* p_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(p_ptr == NULL) return JS_EXCEPTION; + Vector3 p = *p_ptr; + Vector3* a_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(a_ptr == NULL) return JS_EXCEPTION; + Vector3 a = *a_ptr; + Vector3* b_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + if(b_ptr == NULL) return JS_EXCEPTION; + Vector3 b = *b_ptr; + Vector3* c_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[3], js_Vector3_class_id); + if(c_ptr == NULL) return JS_EXCEPTION; + Vector3 c = *c_ptr; + Vector3 returnVal = Vector3Barycenter(p, a, b, c); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Unproject(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* source_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(source_ptr == NULL) return JS_EXCEPTION; + Vector3 source = *source_ptr; + Matrix* projection_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[1], js_Matrix_class_id); + if(projection_ptr == NULL) return JS_EXCEPTION; + Matrix projection = *projection_ptr; + Matrix* view_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[2], js_Matrix_class_id); + if(view_ptr == NULL) return JS_EXCEPTION; + Matrix view = *view_ptr; + Vector3 returnVal = Vector3Unproject(source, projection, view); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Invert(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + Vector3 v = *v_ptr; + Vector3 returnVal = Vector3Invert(v); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Clamp(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + Vector3 v = *v_ptr; + Vector3* min_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(min_ptr == NULL) return JS_EXCEPTION; + Vector3 min = *min_ptr; + Vector3* max_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + if(max_ptr == NULL) return JS_EXCEPTION; + Vector3 max = *max_ptr; + Vector3 returnVal = Vector3Clamp(v, min, max); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3ClampValue(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + Vector3 v = *v_ptr; + double _double_min; + JS_ToFloat64(ctx, &_double_min, argv[1]); + float min = (float)_double_min; + double _double_max; + JS_ToFloat64(ctx, &_double_max, argv[2]); + float max = (float)_double_max; + Vector3 returnVal = Vector3ClampValue(v, min, max); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_vector3Equals(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* p_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(p_ptr == NULL) return JS_EXCEPTION; + Vector3 p = *p_ptr; + Vector3* q_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(q_ptr == NULL) return JS_EXCEPTION; + Vector3 q = *q_ptr; + int returnVal = Vector3Equals(p, q); + JSValue ret = JS_NewInt32(ctx, returnVal); + return ret; +} + +static JSValue js_vector3Refract(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* v_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(v_ptr == NULL) return JS_EXCEPTION; + Vector3 v = *v_ptr; + Vector3* n_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(n_ptr == NULL) return JS_EXCEPTION; + Vector3 n = *n_ptr; + double _double_r; + JS_ToFloat64(ctx, &_double_r, argv[2]); + float r = (float)_double_r; + Vector3 returnVal = Vector3Refract(v, n, r); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixDeterminant(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Matrix* mat_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); + if(mat_ptr == NULL) return JS_EXCEPTION; + Matrix mat = *mat_ptr; + float returnVal = MatrixDeterminant(mat); + JSValue ret = JS_NewFloat64(ctx, returnVal); + return ret; +} + +static JSValue js_matrixTrace(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Matrix* mat_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); + if(mat_ptr == NULL) return JS_EXCEPTION; + Matrix mat = *mat_ptr; + float returnVal = MatrixTrace(mat); + JSValue ret = JS_NewFloat64(ctx, returnVal); + return ret; +} + +static JSValue js_matrixTranspose(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Matrix* mat_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); + if(mat_ptr == NULL) return JS_EXCEPTION; + Matrix mat = *mat_ptr; + Matrix returnVal = MatrixTranspose(mat); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixInvert(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Matrix* mat_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); + if(mat_ptr == NULL) return JS_EXCEPTION; + Matrix mat = *mat_ptr; + Matrix returnVal = MatrixInvert(mat); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixIdentity(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Matrix returnVal = MatrixIdentity(); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixAdd(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Matrix* left_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); + if(left_ptr == NULL) return JS_EXCEPTION; + Matrix left = *left_ptr; + Matrix* right_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[1], js_Matrix_class_id); + if(right_ptr == NULL) return JS_EXCEPTION; + Matrix right = *right_ptr; + Matrix returnVal = MatrixAdd(left, right); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixSubtract(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Matrix* left_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); + if(left_ptr == NULL) return JS_EXCEPTION; + Matrix left = *left_ptr; + Matrix* right_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[1], js_Matrix_class_id); + if(right_ptr == NULL) return JS_EXCEPTION; + Matrix right = *right_ptr; + Matrix returnVal = MatrixSubtract(left, right); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixMultiply(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Matrix* left_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); + if(left_ptr == NULL) return JS_EXCEPTION; + Matrix left = *left_ptr; + Matrix* right_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[1], js_Matrix_class_id); + if(right_ptr == NULL) return JS_EXCEPTION; + Matrix right = *right_ptr; + Matrix returnVal = MatrixMultiply(left, right); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixTranslate(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + double _double_x; + JS_ToFloat64(ctx, &_double_x, argv[0]); + float x = (float)_double_x; + double _double_y; + JS_ToFloat64(ctx, &_double_y, argv[1]); + float y = (float)_double_y; + double _double_z; + JS_ToFloat64(ctx, &_double_z, argv[2]); + float z = (float)_double_z; + Matrix returnVal = MatrixTranslate(x, y, z); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixRotate(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* axis_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(axis_ptr == NULL) return JS_EXCEPTION; + Vector3 axis = *axis_ptr; + double _double_angle; + JS_ToFloat64(ctx, &_double_angle, argv[1]); + float angle = (float)_double_angle; + Matrix returnVal = MatrixRotate(axis, angle); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixRotateX(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + double _double_angle; + JS_ToFloat64(ctx, &_double_angle, argv[0]); + float angle = (float)_double_angle; + Matrix returnVal = MatrixRotateX(angle); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixRotateY(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + double _double_angle; + JS_ToFloat64(ctx, &_double_angle, argv[0]); + float angle = (float)_double_angle; + Matrix returnVal = MatrixRotateY(angle); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixRotateZ(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + double _double_angle; + JS_ToFloat64(ctx, &_double_angle, argv[0]); + float angle = (float)_double_angle; + Matrix returnVal = MatrixRotateZ(angle); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixRotateXYZ(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* angle_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(angle_ptr == NULL) return JS_EXCEPTION; + Vector3 angle = *angle_ptr; + Matrix returnVal = MatrixRotateXYZ(angle); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixRotateZYX(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* angle_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(angle_ptr == NULL) return JS_EXCEPTION; + Vector3 angle = *angle_ptr; + Matrix returnVal = MatrixRotateZYX(angle); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixScale(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + double _double_x; + JS_ToFloat64(ctx, &_double_x, argv[0]); + float x = (float)_double_x; + double _double_y; + JS_ToFloat64(ctx, &_double_y, argv[1]); + float y = (float)_double_y; + double _double_z; + JS_ToFloat64(ctx, &_double_z, argv[2]); + float z = (float)_double_z; + Matrix returnVal = MatrixScale(x, y, z); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixFrustum(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + double left; + JS_ToFloat64(ctx, &left, argv[0]); + double right; + JS_ToFloat64(ctx, &right, argv[1]); + double bottom; + JS_ToFloat64(ctx, &bottom, argv[2]); + double top; + JS_ToFloat64(ctx, &top, argv[3]); + double near; + JS_ToFloat64(ctx, &near, argv[4]); + double far; + JS_ToFloat64(ctx, &far, argv[5]); + Matrix returnVal = MatrixFrustum(left, right, bottom, top, near, far); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixPerspective(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + double fovy; + JS_ToFloat64(ctx, &fovy, argv[0]); + double aspect; + JS_ToFloat64(ctx, &aspect, argv[1]); + double near; + JS_ToFloat64(ctx, &near, argv[2]); + double far; + JS_ToFloat64(ctx, &far, argv[3]); + Matrix returnVal = MatrixPerspective(fovy, aspect, near, far); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixOrtho(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + double left; + JS_ToFloat64(ctx, &left, argv[0]); + double right; + JS_ToFloat64(ctx, &right, argv[1]); + double bottom; + JS_ToFloat64(ctx, &bottom, argv[2]); + double top; + JS_ToFloat64(ctx, &top, argv[3]); + double near; + JS_ToFloat64(ctx, &near, argv[4]); + double far; + JS_ToFloat64(ctx, &far, argv[5]); + Matrix returnVal = MatrixOrtho(left, right, bottom, top, near, far); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_matrixLookAt(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* eye_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(eye_ptr == NULL) return JS_EXCEPTION; + Vector3 eye = *eye_ptr; + Vector3* target_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(target_ptr == NULL) return JS_EXCEPTION; + Vector3 target = *target_ptr; + Vector3* up_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + if(up_ptr == NULL) return JS_EXCEPTION; + Vector3 up = *up_ptr; + Matrix returnVal = MatrixLookAt(eye, target, up); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionAdd(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q1_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q1_ptr == NULL) return JS_EXCEPTION; + Quaternion q1 = *q1_ptr; + Quaternion* q2_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if(q2_ptr == NULL) return JS_EXCEPTION; + Quaternion q2 = *q2_ptr; + Quaternion returnVal = QuaternionAdd(q1, q2); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionAddValue(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q_ptr == NULL) return JS_EXCEPTION; + Quaternion q = *q_ptr; + double _double_add; + JS_ToFloat64(ctx, &_double_add, argv[1]); + float add = (float)_double_add; + Quaternion returnVal = QuaternionAddValue(q, add); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionSubtract(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q1_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q1_ptr == NULL) return JS_EXCEPTION; + Quaternion q1 = *q1_ptr; + Quaternion* q2_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if(q2_ptr == NULL) return JS_EXCEPTION; + Quaternion q2 = *q2_ptr; + Quaternion returnVal = QuaternionSubtract(q1, q2); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionSubtractValue(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q_ptr == NULL) return JS_EXCEPTION; + Quaternion q = *q_ptr; + double _double_sub; + JS_ToFloat64(ctx, &_double_sub, argv[1]); + float sub = (float)_double_sub; + Quaternion returnVal = QuaternionSubtractValue(q, sub); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionIdentity(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion returnVal = QuaternionIdentity(); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionLength(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q_ptr == NULL) return JS_EXCEPTION; + Quaternion q = *q_ptr; + float returnVal = QuaternionLength(q); + JSValue ret = JS_NewFloat64(ctx, returnVal); + return ret; +} + +static JSValue js_quaternionNormalize(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q_ptr == NULL) return JS_EXCEPTION; + Quaternion q = *q_ptr; + Quaternion returnVal = QuaternionNormalize(q); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionInvert(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q_ptr == NULL) return JS_EXCEPTION; + Quaternion q = *q_ptr; + Quaternion returnVal = QuaternionInvert(q); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionMultiply(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q1_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q1_ptr == NULL) return JS_EXCEPTION; + Quaternion q1 = *q1_ptr; + Quaternion* q2_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if(q2_ptr == NULL) return JS_EXCEPTION; + Quaternion q2 = *q2_ptr; + Quaternion returnVal = QuaternionMultiply(q1, q2); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionScale(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q_ptr == NULL) return JS_EXCEPTION; + Quaternion q = *q_ptr; + double _double_mul; + JS_ToFloat64(ctx, &_double_mul, argv[1]); + float mul = (float)_double_mul; + Quaternion returnVal = QuaternionScale(q, mul); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionDivide(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q1_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q1_ptr == NULL) return JS_EXCEPTION; + Quaternion q1 = *q1_ptr; + Quaternion* q2_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if(q2_ptr == NULL) return JS_EXCEPTION; + Quaternion q2 = *q2_ptr; + Quaternion returnVal = QuaternionDivide(q1, q2); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionLerp(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q1_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q1_ptr == NULL) return JS_EXCEPTION; + Quaternion q1 = *q1_ptr; + Quaternion* q2_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if(q2_ptr == NULL) return JS_EXCEPTION; + Quaternion q2 = *q2_ptr; + double _double_amount; + JS_ToFloat64(ctx, &_double_amount, argv[2]); + float amount = (float)_double_amount; + Quaternion returnVal = QuaternionLerp(q1, q2, amount); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionNlerp(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q1_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q1_ptr == NULL) return JS_EXCEPTION; + Quaternion q1 = *q1_ptr; + Quaternion* q2_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if(q2_ptr == NULL) return JS_EXCEPTION; + Quaternion q2 = *q2_ptr; + double _double_amount; + JS_ToFloat64(ctx, &_double_amount, argv[2]); + float amount = (float)_double_amount; + Quaternion returnVal = QuaternionNlerp(q1, q2, amount); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionSlerp(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q1_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q1_ptr == NULL) return JS_EXCEPTION; + Quaternion q1 = *q1_ptr; + Quaternion* q2_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if(q2_ptr == NULL) return JS_EXCEPTION; + Quaternion q2 = *q2_ptr; + double _double_amount; + JS_ToFloat64(ctx, &_double_amount, argv[2]); + float amount = (float)_double_amount; + Quaternion returnVal = QuaternionSlerp(q1, q2, amount); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionFromVector3ToVector3(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* from_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(from_ptr == NULL) return JS_EXCEPTION; + Vector3 from = *from_ptr; + Vector3* to_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + if(to_ptr == NULL) return JS_EXCEPTION; + Vector3 to = *to_ptr; + Quaternion returnVal = QuaternionFromVector3ToVector3(from, to); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionFromMatrix(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Matrix* mat_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); + if(mat_ptr == NULL) return JS_EXCEPTION; + Matrix mat = *mat_ptr; + Quaternion returnVal = QuaternionFromMatrix(mat); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionToMatrix(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q_ptr == NULL) return JS_EXCEPTION; + Quaternion q = *q_ptr; + Matrix returnVal = QuaternionToMatrix(q); + Matrix* ret_ptr = (Matrix*)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionFromAxisAngle(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Vector3* axis_ptr = (Vector3*)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if(axis_ptr == NULL) return JS_EXCEPTION; + Vector3 axis = *axis_ptr; + double _double_angle; + JS_ToFloat64(ctx, &_double_angle, argv[1]); + float angle = (float)_double_angle; + Quaternion returnVal = QuaternionFromAxisAngle(axis, angle); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionFromEuler(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + double _double_pitch; + JS_ToFloat64(ctx, &_double_pitch, argv[0]); + float pitch = (float)_double_pitch; + double _double_yaw; + JS_ToFloat64(ctx, &_double_yaw, argv[1]); + float yaw = (float)_double_yaw; + double _double_roll; + JS_ToFloat64(ctx, &_double_roll, argv[2]); + float roll = (float)_double_roll; + Quaternion returnVal = QuaternionFromEuler(pitch, yaw, roll); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionToEuler(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q_ptr == NULL) return JS_EXCEPTION; + Quaternion q = *q_ptr; + Vector3 returnVal = QuaternionToEuler(q); + Vector3* ret_ptr = (Vector3*)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionTransform(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* q_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(q_ptr == NULL) return JS_EXCEPTION; + Quaternion q = *q_ptr; + Matrix* mat_ptr = (Matrix*)JS_GetOpaque2(ctx, argv[1], js_Matrix_class_id); + if(mat_ptr == NULL) return JS_EXCEPTION; + Matrix mat = *mat_ptr; + Quaternion returnVal = QuaternionTransform(q, mat); + Quaternion* ret_ptr = (Quaternion*)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; +} + +static JSValue js_quaternionEquals(JSContext * ctx, JSValueConst this_val, int argc, JSValueConst * argv) { + Quaternion* p_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if(p_ptr == NULL) return JS_EXCEPTION; + Quaternion p = *p_ptr; + Quaternion* q_ptr = (Quaternion*)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if(q_ptr == NULL) return JS_EXCEPTION; + Quaternion q = *q_ptr; + int returnVal = QuaternionEquals(p, q); + JSValue ret = JS_NewInt32(ctx, returnVal); + return ret; +} + static const JSCFunctionListEntry js_raylib_core_funcs[] = { JS_CFUNC_DEF("initWindow",3,js_initWindow), JS_CFUNC_DEF("windowShouldClose",0,js_windowShouldClose), @@ -5723,6 +7472,7 @@ static const JSCFunctionListEntry js_raylib_core_funcs[] = { JS_CFUNC_DEF("maximizeWindow",0,js_maximizeWindow), JS_CFUNC_DEF("minimizeWindow",0,js_minimizeWindow), JS_CFUNC_DEF("restoreWindow",0,js_restoreWindow), + JS_CFUNC_DEF("setWindowIcon",1,js_setWindowIcon), JS_CFUNC_DEF("setWindowTitle",1,js_setWindowTitle), JS_CFUNC_DEF("setWindowPosition",2,js_setWindowPosition), JS_CFUNC_DEF("setWindowMonitor",1,js_setWindowMonitor), @@ -5761,12 +7511,24 @@ static const JSCFunctionListEntry js_raylib_core_funcs[] = { JS_CFUNC_DEF("endMode2D",0,js_endMode2D), JS_CFUNC_DEF("beginMode3D",1,js_beginMode3D), JS_CFUNC_DEF("endMode3D",0,js_endMode3D), + JS_CFUNC_DEF("beginShaderMode",1,js_beginShaderMode), + JS_CFUNC_DEF("endShaderMode",0,js_endShaderMode), JS_CFUNC_DEF("beginBlendMode",1,js_beginBlendMode), JS_CFUNC_DEF("endBlendMode",0,js_endBlendMode), JS_CFUNC_DEF("beginScissorMode",4,js_beginScissorMode), JS_CFUNC_DEF("endScissorMode",0,js_endScissorMode), + JS_CFUNC_DEF("loadShader",2,js_loadShader), + JS_CFUNC_DEF("isShaderReady",1,js_isShaderReady), + JS_CFUNC_DEF("getShaderLocation",2,js_getShaderLocation), + JS_CFUNC_DEF("getShaderLocationAttrib",2,js_getShaderLocationAttrib), + JS_CFUNC_DEF("setShaderValueMatrix",3,js_setShaderValueMatrix), + JS_CFUNC_DEF("setShaderValueTexture",3,js_setShaderValueTexture), + JS_CFUNC_DEF("getMouseRay",2,js_getMouseRay), + JS_CFUNC_DEF("getCameraMatrix",1,js_getCameraMatrix), JS_CFUNC_DEF("getCameraMatrix2D",1,js_getCameraMatrix2D), + JS_CFUNC_DEF("getWorldToScreen",2,js_getWorldToScreen), JS_CFUNC_DEF("getScreenToWorld2D",2,js_getScreenToWorld2D), + JS_CFUNC_DEF("getWorldToScreenEx",4,js_getWorldToScreenEx), JS_CFUNC_DEF("getWorldToScreen2D",2,js_getWorldToScreen2D), JS_CFUNC_DEF("setTargetFPS",1,js_setTargetFPS), JS_CFUNC_DEF("getFPS",0,js_getFPS), @@ -5840,6 +7602,8 @@ static const JSCFunctionListEntry js_raylib_core_funcs[] = { JS_CFUNC_DEF("getGestureDragAngle",0,js_getGestureDragAngle), JS_CFUNC_DEF("getGesturePinchVector",0,js_getGesturePinchVector), JS_CFUNC_DEF("getGesturePinchAngle",0,js_getGesturePinchAngle), + JS_CFUNC_DEF("updateCamera",2,js_updateCamera), + JS_CFUNC_DEF("updateCameraPro",4,js_updateCameraPro), JS_CFUNC_DEF("drawPixel",3,js_drawPixel), JS_CFUNC_DEF("drawPixelV",2,js_drawPixelV), JS_CFUNC_DEF("drawLine",5,js_drawLine), @@ -5900,12 +7664,53 @@ static const JSCFunctionListEntry js_raylib_core_funcs[] = { JS_CFUNC_DEF("imageCopy",1,js_imageCopy), JS_CFUNC_DEF("imageFromImage",2,js_imageFromImage), JS_CFUNC_DEF("imageText",3,js_imageText), + JS_CFUNC_DEF("imageTextEx",5,js_imageTextEx), + JS_CFUNC_DEF("imageFormat",2,js_imageFormat), + JS_CFUNC_DEF("imageToPOT",2,js_imageToPOT), + JS_CFUNC_DEF("imageCrop",2,js_imageCrop), + JS_CFUNC_DEF("imageAlphaCrop",2,js_imageAlphaCrop), + JS_CFUNC_DEF("imageAlphaClear",3,js_imageAlphaClear), + JS_CFUNC_DEF("imageAlphaMask",2,js_imageAlphaMask), + JS_CFUNC_DEF("imageAlphaPremultiply",1,js_imageAlphaPremultiply), + JS_CFUNC_DEF("imageBlurGaussian",2,js_imageBlurGaussian), + JS_CFUNC_DEF("imageResize",3,js_imageResize), + JS_CFUNC_DEF("imageResizeNN",3,js_imageResizeNN), + JS_CFUNC_DEF("imageResizeCanvas",6,js_imageResizeCanvas), + JS_CFUNC_DEF("imageMipmaps",1,js_imageMipmaps), + JS_CFUNC_DEF("imageDither",5,js_imageDither), + JS_CFUNC_DEF("imageFlipVertical",1,js_imageFlipVertical), + JS_CFUNC_DEF("imageFlipHorizontal",1,js_imageFlipHorizontal), + JS_CFUNC_DEF("imageRotateCW",1,js_imageRotateCW), + JS_CFUNC_DEF("imageRotateCCW",1,js_imageRotateCCW), + JS_CFUNC_DEF("imageColorTint",2,js_imageColorTint), + JS_CFUNC_DEF("imageColorInvert",1,js_imageColorInvert), + JS_CFUNC_DEF("imageColorGrayscale",1,js_imageColorGrayscale), + JS_CFUNC_DEF("imageColorContrast",2,js_imageColorContrast), + JS_CFUNC_DEF("imageColorBrightness",2,js_imageColorBrightness), + JS_CFUNC_DEF("imageColorReplace",3,js_imageColorReplace), JS_CFUNC_DEF("getImageAlphaBorder",2,js_getImageAlphaBorder), JS_CFUNC_DEF("getImageColor",3,js_getImageColor), + JS_CFUNC_DEF("imageClearBackground",2,js_imageClearBackground), + JS_CFUNC_DEF("imageDrawPixel",4,js_imageDrawPixel), + JS_CFUNC_DEF("imageDrawPixelV",3,js_imageDrawPixelV), + JS_CFUNC_DEF("imageDrawLine",6,js_imageDrawLine), + JS_CFUNC_DEF("imageDrawLineV",4,js_imageDrawLineV), + JS_CFUNC_DEF("imageDrawCircle",5,js_imageDrawCircle), + JS_CFUNC_DEF("imageDrawCircleV",4,js_imageDrawCircleV), + JS_CFUNC_DEF("imageDrawCircleLines",5,js_imageDrawCircleLines), + JS_CFUNC_DEF("imageDrawCircleLinesV",4,js_imageDrawCircleLinesV), + JS_CFUNC_DEF("imageDrawRectangle",6,js_imageDrawRectangle), + JS_CFUNC_DEF("imageDrawRectangleV",4,js_imageDrawRectangleV), + JS_CFUNC_DEF("imageDrawRectangleRec",3,js_imageDrawRectangleRec), + JS_CFUNC_DEF("imageDrawRectangleLines",4,js_imageDrawRectangleLines), + JS_CFUNC_DEF("imageDraw",5,js_imageDraw), + JS_CFUNC_DEF("imageDrawText",6,js_imageDrawText), + JS_CFUNC_DEF("imageDrawTextEx",7,js_imageDrawTextEx), JS_CFUNC_DEF("loadTexture",1,js_loadTexture), JS_CFUNC_DEF("loadTextureFromImage",1,js_loadTextureFromImage), JS_CFUNC_DEF("loadTextureCubemap",2,js_loadTextureCubemap), JS_CFUNC_DEF("isTextureReady",1,js_isTextureReady), + JS_CFUNC_DEF("genTextureMipmaps",1,js_genTextureMipmaps), JS_CFUNC_DEF("setTextureFilter",2,js_setTextureFilter), JS_CFUNC_DEF("setTextureWrap",2,js_setTextureWrap), JS_CFUNC_DEF("drawTexture",4,js_drawTexture), @@ -5971,8 +7776,10 @@ static const JSCFunctionListEntry js_raylib_core_funcs[] = { JS_CFUNC_DEF("drawBillboard",5,js_drawBillboard), JS_CFUNC_DEF("drawBillboardRec",6,js_drawBillboardRec), JS_CFUNC_DEF("drawBillboardPro",9,js_drawBillboardPro), + JS_CFUNC_DEF("uploadMesh",2,js_uploadMesh), JS_CFUNC_DEF("exportMesh",2,js_exportMesh), JS_CFUNC_DEF("getMeshBoundingBox",1,js_getMeshBoundingBox), + JS_CFUNC_DEF("genMeshTangents",1,js_genMeshTangents), JS_CFUNC_DEF("genMeshPoly",2,js_genMeshPoly), JS_CFUNC_DEF("genMeshPlane",4,js_genMeshPlane), JS_CFUNC_DEF("genMeshCube",3,js_genMeshCube), @@ -6011,6 +7818,8 @@ static const JSCFunctionListEntry js_raylib_core_funcs[] = { JS_CFUNC_DEF("setSoundPitch",2,js_setSoundPitch), JS_CFUNC_DEF("setSoundPan",2,js_setSoundPan), JS_CFUNC_DEF("waveCopy",1,js_waveCopy), + JS_CFUNC_DEF("waveCrop",3,js_waveCrop), + JS_CFUNC_DEF("waveFormat",4,js_waveFormat), JS_CFUNC_DEF("loadMusicStream",1,js_loadMusicStream), JS_CFUNC_DEF("isMusicReady",1,js_isMusicReady), JS_CFUNC_DEF("playMusicStream",1,js_playMusicStream), @@ -6062,6 +7871,77 @@ static const JSCFunctionListEntry js_raylib_core_funcs[] = { JS_CFUNC_DEF("vector3One",0,js_vector3One), JS_CFUNC_DEF("vector3Add",2,js_vector3Add), JS_CFUNC_DEF("vector3AddValue",2,js_vector3AddValue), + JS_CFUNC_DEF("vector3Subtract",2,js_vector3Subtract), + JS_CFUNC_DEF("vector3SubtractValue",2,js_vector3SubtractValue), + JS_CFUNC_DEF("vector3Scale",2,js_vector3Scale), + JS_CFUNC_DEF("vector3Multiply",2,js_vector3Multiply), + JS_CFUNC_DEF("vector3CrossProduct",2,js_vector3CrossProduct), + JS_CFUNC_DEF("vector3Perpendicular",1,js_vector3Perpendicular), + JS_CFUNC_DEF("vector3Length",1,js_vector3Length), + JS_CFUNC_DEF("vector3LengthSqr",1,js_vector3LengthSqr), + JS_CFUNC_DEF("vector3DotProduct",2,js_vector3DotProduct), + JS_CFUNC_DEF("vector3Distance",2,js_vector3Distance), + JS_CFUNC_DEF("vector3DistanceSqr",2,js_vector3DistanceSqr), + JS_CFUNC_DEF("vector3Angle",2,js_vector3Angle), + JS_CFUNC_DEF("vector3Negate",1,js_vector3Negate), + JS_CFUNC_DEF("vector3Divide",2,js_vector3Divide), + JS_CFUNC_DEF("vector3Normalize",1,js_vector3Normalize), + JS_CFUNC_DEF("vector3Transform",2,js_vector3Transform), + JS_CFUNC_DEF("vector3RotateByQuaternion",2,js_vector3RotateByQuaternion), + JS_CFUNC_DEF("vector3RotateByAxisAngle",3,js_vector3RotateByAxisAngle), + JS_CFUNC_DEF("vector3Lerp",3,js_vector3Lerp), + JS_CFUNC_DEF("vector3Reflect",2,js_vector3Reflect), + JS_CFUNC_DEF("vector3Min",2,js_vector3Min), + JS_CFUNC_DEF("vector3Max",2,js_vector3Max), + JS_CFUNC_DEF("vector3Barycenter",4,js_vector3Barycenter), + JS_CFUNC_DEF("vector3Unproject",3,js_vector3Unproject), + JS_CFUNC_DEF("vector3Invert",1,js_vector3Invert), + JS_CFUNC_DEF("vector3Clamp",3,js_vector3Clamp), + JS_CFUNC_DEF("vector3ClampValue",3,js_vector3ClampValue), + JS_CFUNC_DEF("vector3Equals",2,js_vector3Equals), + JS_CFUNC_DEF("vector3Refract",3,js_vector3Refract), + JS_CFUNC_DEF("matrixDeterminant",1,js_matrixDeterminant), + JS_CFUNC_DEF("matrixTrace",1,js_matrixTrace), + JS_CFUNC_DEF("matrixTranspose",1,js_matrixTranspose), + JS_CFUNC_DEF("matrixInvert",1,js_matrixInvert), + JS_CFUNC_DEF("matrixIdentity",0,js_matrixIdentity), + JS_CFUNC_DEF("matrixAdd",2,js_matrixAdd), + JS_CFUNC_DEF("matrixSubtract",2,js_matrixSubtract), + JS_CFUNC_DEF("matrixMultiply",2,js_matrixMultiply), + JS_CFUNC_DEF("matrixTranslate",3,js_matrixTranslate), + JS_CFUNC_DEF("matrixRotate",2,js_matrixRotate), + JS_CFUNC_DEF("matrixRotateX",1,js_matrixRotateX), + JS_CFUNC_DEF("matrixRotateY",1,js_matrixRotateY), + JS_CFUNC_DEF("matrixRotateZ",1,js_matrixRotateZ), + JS_CFUNC_DEF("matrixRotateXYZ",1,js_matrixRotateXYZ), + JS_CFUNC_DEF("matrixRotateZYX",1,js_matrixRotateZYX), + JS_CFUNC_DEF("matrixScale",3,js_matrixScale), + JS_CFUNC_DEF("matrixFrustum",6,js_matrixFrustum), + JS_CFUNC_DEF("matrixPerspective",4,js_matrixPerspective), + JS_CFUNC_DEF("matrixOrtho",6,js_matrixOrtho), + JS_CFUNC_DEF("matrixLookAt",3,js_matrixLookAt), + JS_CFUNC_DEF("quaternionAdd",2,js_quaternionAdd), + JS_CFUNC_DEF("quaternionAddValue",2,js_quaternionAddValue), + JS_CFUNC_DEF("quaternionSubtract",2,js_quaternionSubtract), + JS_CFUNC_DEF("quaternionSubtractValue",2,js_quaternionSubtractValue), + JS_CFUNC_DEF("quaternionIdentity",0,js_quaternionIdentity), + JS_CFUNC_DEF("quaternionLength",1,js_quaternionLength), + JS_CFUNC_DEF("quaternionNormalize",1,js_quaternionNormalize), + JS_CFUNC_DEF("quaternionInvert",1,js_quaternionInvert), + JS_CFUNC_DEF("quaternionMultiply",2,js_quaternionMultiply), + JS_CFUNC_DEF("quaternionScale",2,js_quaternionScale), + JS_CFUNC_DEF("quaternionDivide",2,js_quaternionDivide), + JS_CFUNC_DEF("quaternionLerp",3,js_quaternionLerp), + JS_CFUNC_DEF("quaternionNlerp",3,js_quaternionNlerp), + JS_CFUNC_DEF("quaternionSlerp",3,js_quaternionSlerp), + JS_CFUNC_DEF("quaternionFromVector3ToVector3",2,js_quaternionFromVector3ToVector3), + JS_CFUNC_DEF("quaternionFromMatrix",1,js_quaternionFromMatrix), + JS_CFUNC_DEF("quaternionToMatrix",1,js_quaternionToMatrix), + JS_CFUNC_DEF("quaternionFromAxisAngle",2,js_quaternionFromAxisAngle), + JS_CFUNC_DEF("quaternionFromEuler",3,js_quaternionFromEuler), + JS_CFUNC_DEF("quaternionToEuler",1,js_quaternionToEuler), + JS_CFUNC_DEF("quaternionTransform",2,js_quaternionTransform), + JS_CFUNC_DEF("quaternionEquals",2,js_quaternionEquals), }; static int js_raylib_core_init(JSContext * ctx, JSModuleDef * m) { @@ -6442,6 +8322,11 @@ static int js_raylib_core_init(JSContext * ctx, JSModuleDef * m) { JS_SetModuleExport(ctx, m, "PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA", JS_NewInt32(ctx, PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)); JS_SetModuleExport(ctx, m, "CAMERA_PERSPECTIVE", JS_NewInt32(ctx, CAMERA_PERSPECTIVE)); JS_SetModuleExport(ctx, m, "CAMERA_ORTHOGRAPHIC", JS_NewInt32(ctx, CAMERA_ORTHOGRAPHIC)); + JS_SetModuleExport(ctx, m, "CAMERA_CUSTOM", JS_NewInt32(ctx, CAMERA_CUSTOM)); + JS_SetModuleExport(ctx, m, "CAMERA_FREE", JS_NewInt32(ctx, CAMERA_FREE)); + JS_SetModuleExport(ctx, m, "CAMERA_ORBITAL", JS_NewInt32(ctx, CAMERA_ORBITAL)); + JS_SetModuleExport(ctx, m, "CAMERA_FIRST_PERSON", JS_NewInt32(ctx, CAMERA_FIRST_PERSON)); + JS_SetModuleExport(ctx, m, "CAMERA_THIRD_PERSON", JS_NewInt32(ctx, CAMERA_THIRD_PERSON)); return 0; } @@ -6667,6 +8552,11 @@ JSModuleDef * js_init_module_raylib_core(JSContext * ctx, const char * module_na JS_AddModuleExport(ctx, m, "PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA"); JS_AddModuleExport(ctx, m, "CAMERA_PERSPECTIVE"); JS_AddModuleExport(ctx, m, "CAMERA_ORTHOGRAPHIC"); + JS_AddModuleExport(ctx, m, "CAMERA_CUSTOM"); + JS_AddModuleExport(ctx, m, "CAMERA_FREE"); + JS_AddModuleExport(ctx, m, "CAMERA_ORBITAL"); + JS_AddModuleExport(ctx, m, "CAMERA_FIRST_PERSON"); + JS_AddModuleExport(ctx, m, "CAMERA_THIRD_PERSON"); return m; } diff --git a/thirdparty/raylib b/thirdparty/raylib index 5573f0f..a48bb6e 160000 --- a/thirdparty/raylib +++ b/thirdparty/raylib @@ -1 +1 @@ -Subproject commit 5573f0f1c7b29bfe46d0b70487e4adb4d01cba62 +Subproject commit a48bb6e1ed7b33190e486ba65b7875f0dff73701