indrajith/RCBASIC4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed compile errors in switch cases

Browse Source
This commit is contained in:
n00b
2024-09-15 22:37:32 -04:00
parent f013e6ba71
commit 526478b618
14 changed files with 2297 additions and 1097 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
rcbasic_build/rc_builtin.h
View File

@@ -493,7 +493,7 @@ void init_embedded_functions()
add_embedded_arg("a", ID_TYPE_NUM);
embed_function("GetCanvasAlpha", ID_TYPE_FN_NUM);
add_embedded_arg("c_num", ID_TYPE_NUM);
embed_function("SetCanvasColorMod", ID_TYPE_FN_NUM);
embed_function("SetCanvasColorMod", ID_TYPE_SUB);
add_embedded_arg("c_num", ID_TYPE_NUM);
add_embedded_arg("c", ID_TYPE_NUM);
embed_function("GetCanvasColorMod", ID_TYPE_FN_NUM);
@@ -610,11 +610,10 @@ void init_embedded_functions()
embed_function("SetBlendMode", ID_TYPE_SUB);
add_embedded_arg("blend_mode", ID_TYPE_NUM);
embed_function("GetBlendMode", ID_TYPE_FN_NUM);
add_embedded_arg("blend_mode", ID_TYPE_NUM);
embed_function("SetImageColorMod", ID_TYPE_FN_NUM);
embed_function("SetImageColorMod", ID_TYPE_SUB);
add_embedded_arg("slot", ID_TYPE_NUM);
add_embedded_arg("c", ID_TYPE_NUM);
embed_function("ImageColorMod", ID_TYPE_FN_NUM);
embed_function("GetImageColorMod", ID_TYPE_FN_NUM);
add_embedded_arg("slot", ID_TYPE_NUM);
embed_function("DrawImage", ID_TYPE_SUB);
add_embedded_arg("slot", ID_TYPE_NUM);
@@ -744,7 +743,7 @@ void init_embedded_functions()
add_embedded_arg("w", ID_TYPE_NUM);
add_embedded_arg("h", ID_TYPE_NUM);
embed_function("ClearMouseZone", ID_TYPE_SUB);
embed_function("SoundFromBuffer", ID_TYPE_FN_NUM);
embed_function("CreateSound", ID_TYPE_FN_NUM);
add_embedded_arg("buffer", ID_TYPE_BYREF_NUM);
add_embedded_arg("buffer_size", ID_TYPE_NUM);
add_embedded_arg("vol", ID_TYPE_NUM);
@@ -872,9 +871,6 @@ void init_embedded_functions()
add_embedded_arg("txt$", ID_TYPE_STR);
add_embedded_arg("x", ID_TYPE_NUM);
add_embedded_arg("y", ID_TYPE_NUM);
embed_function("RenderText", ID_TYPE_SUB);
add_embedded_arg("slot", ID_TYPE_NUM);
add_embedded_arg("txt$", ID_TYPE_STR);
embed_function("GetTextSize", ID_TYPE_SUB);
add_embedded_arg("txt$", ID_TYPE_STR);
add_embedded_arg("w", ID_TYPE_BYREF_NUM);
@@ -936,8 +932,8 @@ void init_embedded_functions()
add_embedded_arg("socket", ID_TYPE_NUM);
embed_function("TCP_GetData", ID_TYPE_FN_NUM);
add_embedded_arg("socket", ID_TYPE_NUM);
add_embedded_arg("sData$", ID_TYPE_BYREF_STR);
add_embedded_arg("numBytes", ID_TYPE_NUM);
add_embedded_arg("sData$", ID_TYPE_BYREF_STR);
embed_function("TCP_SendData", ID_TYPE_SUB);
add_embedded_arg("socket", ID_TYPE_NUM);
add_embedded_arg("sData$", ID_TYPE_STR);
@@ -950,9 +946,9 @@ void init_embedded_functions()
add_embedded_arg("socket", ID_TYPE_NUM);
embed_function("UDP_GetData", ID_TYPE_FN_NUM);
add_embedded_arg("socket", ID_TYPE_NUM);
add_embedded_arg("sData$", ID_TYPE_BYREF_STR);
add_embedded_arg("host$", ID_TYPE_BYREF_STR);
add_embedded_arg("port", ID_TYPE_BYREF_NUM);
add_embedded_arg("sData$", ID_TYPE_BYREF_STR);
embed_function("UDP_Length", ID_TYPE_FN_NUM);
embed_function("UDP_MaxLength", ID_TYPE_FN_NUM);
embed_function("UDP_RemoteHost$", ID_TYPE_FN_STR);
@@ -961,9 +957,9 @@ void init_embedded_functions()
add_embedded_arg("socket", ID_TYPE_NUM);
embed_function("UDP_SendData", ID_TYPE_SUB);
add_embedded_arg("socket", ID_TYPE_NUM);
add_embedded_arg("sData$", ID_TYPE_STR);
add_embedded_arg("host$", ID_TYPE_STR);
add_embedded_arg("port", ID_TYPE_NUM);
add_embedded_arg("sData$", ID_TYPE_STR);
embed_function("LoadVideo", ID_TYPE_SUB);
add_embedded_arg("vid$", ID_TYPE_STR);
embed_function("PlayVideo", ID_TYPE_SUB);
@@ -997,12 +993,9 @@ void init_embedded_functions()
add_embedded_arg("w", ID_TYPE_BYREF_NUM);
add_embedded_arg("h", ID_TYPE_BYREF_NUM);
embed_function("VideoExists", ID_TYPE_FN_NUM);
embed_function("SetVideoAlpha", ID_TYPE_SUB);
add_embedded_arg("a", ID_TYPE_NUM);
embed_function("SetVideoVolume", ID_TYPE_SUB);
add_embedded_arg("vol", ID_TYPE_NUM);
embed_function("GetVideoVolume", ID_TYPE_FN_NUM);
add_embedded_arg("vol", ID_TYPE_NUM);
embed_function("System", ID_TYPE_FN_NUM);
add_embedded_arg("cmd$", ID_TYPE_STR);
embed_function("OS$", ID_TYPE_FN_STR);
@@ -1044,6 +1037,7 @@ void init_embedded_functions()
add_embedded_arg("msg$", ID_TYPE_STR);
embed_function("Runtime$", ID_TYPE_FN_STR);
embed_function("NumCPUs", ID_TYPE_FN_NUM);
embed_function("SystemRam", ID_TYPE_FN_NUM);
embed_function("DimMatrix", ID_TYPE_FN_NUM);
add_embedded_arg("m_rows", ID_TYPE_NUM);
add_embedded_arg("m_cols", ID_TYPE_NUM);
@@ -1116,7 +1110,7 @@ void init_embedded_functions()
add_embedded_arg("mB", ID_TYPE_NUM);
add_embedded_arg("r", ID_TYPE_NUM);
add_embedded_arg("num_rows", ID_TYPE_NUM);
embed_function("IdentityMatrix", ID_TYPE_SUB);
embed_function("SetIdentityMatrix", ID_TYPE_SUB);
add_embedded_arg("mA", ID_TYPE_NUM);
add_embedded_arg("n", ID_TYPE_NUM);
embed_function("SolveMatrix", ID_TYPE_FN_NUM);
@@ -1140,7 +1134,7 @@ void init_embedded_functions()
add_embedded_arg("r", ID_TYPE_NUM);
add_embedded_arg("c", ID_TYPE_NUM);
add_embedded_arg("buffer", ID_TYPE_BYREF_NUM);
embed_function("GetMatrix", ID_TYPE_SUB);
embed_function("BufferFromMatrix", ID_TYPE_SUB);
add_embedded_arg("buffer", ID_TYPE_BYREF_NUM);
add_embedded_arg("mA", ID_TYPE_NUM);
embed_function("RandomizeMatrix", ID_TYPE_SUB);
@@ -1264,7 +1258,7 @@ void init_embedded_functions()
add_embedded_arg("x", ID_TYPE_BYREF_NUM);
add_embedded_arg("y", ID_TYPE_BYREF_NUM);
add_embedded_arg("z", ID_TYPE_BYREF_NUM);
embed_function("ClipboardText$", ID_TYPE_FN_STR);
embed_function("GetClipboardText$", ID_TYPE_FN_STR);
embed_function("SetClipboardText", ID_TYPE_SUB);
add_embedded_arg("txt$", ID_TYPE_STR);
embed_function("HasClipboardText", ID_TYPE_FN_NUM);
@@ -1450,6 +1444,7 @@ void init_embedded_functions()
add_embedded_arg("actor", ID_TYPE_NUM);
embed_function("integrateActorVelocities", ID_TYPE_SUB);
add_embedded_arg("actor", ID_TYPE_NUM);
add_embedded_arg("v_step", ID_TYPE_NUM);
embed_function("applyActorCentralForceLocal", ID_TYPE_SUB);
add_embedded_arg("actor", ID_TYPE_NUM);
add_embedded_arg("x", ID_TYPE_NUM);
@@ -2077,6 +2072,7 @@ void init_embedded_functions()
add_embedded_arg("actor", ID_TYPE_NUM);
embed_function("setParticleNormalDirectionMod", ID_TYPE_SUB);
add_embedded_arg("actor", ID_TYPE_NUM);
add_embedded_arg("nd_mod", ID_TYPE_NUM);
embed_function("getParticleNormalDirectionMod", ID_TYPE_FN_NUM);
add_embedded_arg("actor", ID_TYPE_NUM);
embed_function("useParticleNormalDirection", ID_TYPE_SUB);
@@ -2329,10 +2325,10 @@ void init_embedded_functions()
embed_function("SetActorFrame", ID_TYPE_SUB);
add_embedded_arg("actor", ID_TYPE_NUM);
add_embedded_arg("frame", ID_TYPE_NUM);
embed_function("SetActorMD2Animation", ID_TYPE_FN_NUM);
embed_function("SetActorMD2Animation", ID_TYPE_SUB);
add_embedded_arg("actor", ID_TYPE_NUM);
add_embedded_arg("anim", ID_TYPE_NUM);
embed_function("SetActorMD2AnimationByName", ID_TYPE_FN_NUM);
embed_function("SetActorMD2AnimationByName", ID_TYPE_SUB);
add_embedded_arg("actor", ID_TYPE_NUM);
add_embedded_arg("anim_name$", ID_TYPE_STR);
embed_function("GetActorAnimationSpeed", ID_TYPE_FN_NUM);
@@ -2435,7 +2431,7 @@ void init_embedded_functions()
embed_function("setMaterialGouraudShading", ID_TYPE_SUB);
add_embedded_arg("material_id", ID_TYPE_NUM);
add_embedded_arg("flag", ID_TYPE_NUM);
embed_function("materialGouraudShading", ID_TYPE_FN_NUM);
embed_function("materialIsGouraudShaded", ID_TYPE_FN_NUM);
add_embedded_arg("material_id", ID_TYPE_NUM);
embed_function("materialIsAplhaBlend", ID_TYPE_FN_NUM);
add_embedded_arg("material_id", ID_TYPE_NUM);

BIN
rcbasic_build/rcbasic4_changes.ods
View File

Binary file not shown.

308
rcbasic_runtime/RealisticWater.cpp Executable file
View File

@@ -0,0 +1,308 @@
/*
* Copyright (c) 2013, elvman
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY elvman ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "RealisticWater.h"
RealisticWaterSceneNode::RealisticWaterSceneNode(scene::ISceneManager* sceneManager, f32 width, f32 height,
const irr::core::stringc& resourcePath, core::dimension2du renderTargetSize,
scene::ISceneNode* parent, s32 id):
scene::ISceneNode(parent, sceneManager, id), _time(0),
_size(width, height), _sceneManager(sceneManager), _refractionMap(NULL), _reflectionMap(NULL),
_windForce(20.0f),_windDirection(0, 1),_waveHeight(0.3f), _waterColor(0.1f, 0.1f, 0.6f, 1.0f), _colorBlendFactor(0.2f), _camera(NULL)
{
_videoDriver = sceneManager->getVideoDriver();
//create new camera
_camera = sceneManager->addCameraSceneNode(0, core::vector3df(0, 0, 0), core::vector3df(0, 0, 0), -1, false);
_waterMesh = sceneManager->addHillPlaneMesh("RealisticWater", _size, core::dimension2d<u32>(1, 1));
_waterSceneNode = sceneManager->addMeshSceneNode(_waterMesh->getMesh(0), this);
video::IGPUProgrammingServices* GPUProgrammingServices = _videoDriver->getGPUProgrammingServices();
core::stringc waterPixelShader;
core::stringc waterVertexShader;
if (_videoDriver->getDriverType() == video::EDT_DIRECT3D9)
{
waterPixelShader = resourcePath + "/shaders/Water_ps.hlsl";
waterVertexShader = resourcePath + "/shaders/Water_vs.hlsl";
}
else if (_videoDriver->getDriverType() == video::EDT_OPENGL)
{
waterPixelShader = resourcePath + "/shaders/Water_ps.glsl";
waterVertexShader = resourcePath + "/shaders/Water_vs.glsl";
}
_shaderMaterial = GPUProgrammingServices->addHighLevelShaderMaterialFromFiles(
waterVertexShader.c_str(), "main", video::EVST_VS_1_1,
waterPixelShader.c_str(), "main", video::EPST_PS_1_1,
this);
_waterSceneNode->setMaterialType((video::E_MATERIAL_TYPE)_shaderMaterial);
irr::video::ITexture* bumpTexture = _videoDriver->getTexture(resourcePath + "/data/waterbump.png");
_waterSceneNode->setMaterialTexture(0, bumpTexture);
_refractionMap = _videoDriver->addRenderTargetTexture(renderTargetSize);
_reflectionMap = _videoDriver->addRenderTargetTexture(renderTargetSize);
_waterSceneNode->setMaterialTexture(1, _refractionMap);
_waterSceneNode->setMaterialTexture(2, _reflectionMap);
}
RealisticWaterSceneNode::~RealisticWaterSceneNode()
{
if (_camera)
{
_camera->drop();
_camera = NULL;
}
if (_refractionMap)
{
_refractionMap->drop();
_refractionMap = NULL;
}
if (_reflectionMap)
{
_reflectionMap->drop();
_reflectionMap = NULL;
}
if (_waterSceneNode)
{
_waterSceneNode->drop();
_waterSceneNode = NULL;
}
if (_waterMesh)
{
_waterMesh->drop();
_waterMesh = NULL;
}
}
// frame
void RealisticWaterSceneNode::OnRegisterSceneNode()
{
ISceneNode::OnRegisterSceneNode();
if (IsVisible)
{
_sceneManager->registerNodeForRendering(this);
}
}
void RealisticWaterSceneNode::OnAnimate(u32 timeMs)
{
ISceneNode::OnAnimate(timeMs);
_time = timeMs;
//fixes glitches with incomplete refraction
const f32 CLIP_PLANE_OFFSET_Y = 5.0f;
if (IsVisible)
{
setVisible(false); //hide the water
//refraction
_videoDriver->setRenderTarget(_refractionMap, true, true); //render to refraction
//refraction clipping plane
core::plane3d<f32> refractionClipPlane(0, RelativeTranslation.Y + CLIP_PLANE_OFFSET_Y, 0, 0, -1, 0); //refraction clip plane
_videoDriver->setClipPlane(0, refractionClipPlane, true);
_sceneManager->drawAll(); //draw the scene
//reflection
_videoDriver->setRenderTarget(_reflectionMap, true, true); //render to reflection
//get current camera
scene::ICameraSceneNode* currentCamera = _sceneManager->getActiveCamera();
//set FOV anf far value from current camera
_camera->setFarValue(currentCamera->getFarValue());
_camera->setFOV(currentCamera->getFOV());
core::vector3df position = currentCamera->getAbsolutePosition();
position.Y = -position.Y + 2 * RelativeTranslation.Y; //position of the water
_camera->setPosition(position);
core::vector3df target = currentCamera->getTarget();
//invert Y position of current camera
target.Y = -target.Y + 2 * RelativeTranslation.Y;
_camera->setTarget(target);
//set the reflection camera
_sceneManager->setActiveCamera(_camera);
//reflection clipping plane
core::plane3d<f32> reflectionClipPlane(0, RelativeTranslation.Y - CLIP_PLANE_OFFSET_Y, 0, 0, 1, 0);
_videoDriver->setClipPlane(0, reflectionClipPlane, true);
_sceneManager->drawAll(); //draw the scene
//disable clip plane
_videoDriver->enableClipPlane(0, false);
//set back old render target
_videoDriver->setRenderTarget(0);
//set back the active camera
_sceneManager->setActiveCamera(currentCamera);
setVisible(true); //show it again
}
}
void RealisticWaterSceneNode::render()
{
/*core::array<video::IRenderTarget> renderTargets;
//renderTargets.push_back();
renderTargets.push_back(_refractionMap);
_videoDriver->setRenderTarget(renderTargets, true, true);*/
//_videoDriver->draw2DImage(_reflectionMap,core::position2d<s32>(0,0));
}
// returns the axis aligned bounding box of terrain
const core::aabbox3d<f32>& RealisticWaterSceneNode::getBoundingBox() const
{
return _waterSceneNode->getBoundingBox();
}
void RealisticWaterSceneNode::OnSetConstants(video::IMaterialRendererServices* services, s32 userData)
{
video::IVideoDriver* driver = services->getVideoDriver();
core::matrix4 projection = driver->getTransform(video::ETS_PROJECTION);
core::matrix4 view = driver->getTransform(video::ETS_VIEW);
core::matrix4 world = driver->getTransform(video::ETS_WORLD);
core::matrix4 cameraView = _camera->getViewMatrix();
//vertex shader constants
//services->setVertexShaderConstant("View", view.pointer(), 16);
core::matrix4 worldViewProj = projection;
worldViewProj *= view;
worldViewProj *= world;
core::matrix4 worldReflectionViewProj = projection;
worldReflectionViewProj *= cameraView;
worldReflectionViewProj *= world;
f32 waveLength = 0.1f;
f32 time = _time / 100000.0f;
core::vector3df cameraPosition = _sceneManager->getActiveCamera()->getPosition();
bool fogEnabled = getMaterial(0).getFlag(video::EMF_FOG_ENABLE);
irr::video::SColor color;
irr::video::E_FOG_TYPE fogType;
f32 start;
f32 end;
f32 density;
bool pixelFog;
bool rangeFog;
driver->getFog(color, fogType, start, end, density, pixelFog, rangeFog);
#if (IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR == 9)
services->setVertexShaderConstant(services->getVertexShaderConstantID("WorldViewProj"), worldViewProj.pointer(), 16);
services->setVertexShaderConstant(services->getVertexShaderConstantID("WorldReflectionViewProj"), worldReflectionViewProj.pointer(), 16);
services->setVertexShaderConstant(services->getVertexShaderConstantID("WaveLength"), &waveLength, 1);
services->setVertexShaderConstant(services->getVertexShaderConstantID("Time"), &time, 1);
services->setVertexShaderConstant(services->getVertexShaderConstantID("WindForce"), &_windForce, 1);
services->setVertexShaderConstant(services->getVertexShaderConstantID("WindDirection"), &_windDirection.X, 2);
services->setPixelShaderConstant(services->getVertexShaderConstantID("CameraPosition"), &cameraPosition.X, 3);
services->setPixelShaderConstant(services->getVertexShaderConstantID("WaveHeight"), &_waveHeight, 1);
services->setPixelShaderConstant(services->getVertexShaderConstantID("WaterColor"), &_waterColor.r, 4);
services->setPixelShaderConstant(services->getVertexShaderConstantID("ColorBlendFactor"), &_colorBlendFactor, 1);
#else
services->setVertexShaderConstant("WorldViewProj", worldViewProj.pointer(), 16);
services->setVertexShaderConstant("WorldReflectionViewProj", worldReflectionViewProj.pointer(), 16);
services->setVertexShaderConstant("WaveLength", &waveLength, 1);
services->setVertexShaderConstant("Time", &time, 1);
services->setVertexShaderConstant("WindForce", &_windForce, 1);
services->setVertexShaderConstant("WindDirection", &_windDirection.X, 2);
services->setPixelShaderConstant("CameraPosition", &cameraPosition.X, 3);
services->setPixelShaderConstant("WaveHeight", &_waveHeight, 1);
services->setPixelShaderConstant("WaterColor", &_waterColor.r, 4);
services->setPixelShaderConstant("ColorBlendFactor", &_colorBlendFactor, 1);
#endif
//texture constants for GLSL
if (driver->getDriverType() == video::EDT_OPENGL)
{
int var0 = 0;
int var1 = 1;
int var2 = 2;
#if (IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR == 9)
services->setPixelShaderConstant(services->getVertexShaderConstantID("WaterBump"), &var0, 1);
services->setPixelShaderConstant(services->getVertexShaderConstantID("RefractionMap"), &var1, 1);
services->setPixelShaderConstant(services->getVertexShaderConstantID("ReflectionMap"), &var2, 1);
services->setPixelShaderConstant(services->getVertexShaderConstantID("FogEnabled"), (int*)&fogEnabled, 1);
services->setPixelShaderConstant(services->getVertexShaderConstantID("FogMode"), (int*)&fogType, 1);
#else
services->setPixelShaderConstant("WaterBump", &var0, 1);
services->setPixelShaderConstant("RefractionMap", &var1, 1);
services->setPixelShaderConstant("ReflectionMap", &var2, 1);
services->setPixelShaderConstant("FogEnabled", (int*)&fogEnabled, 1);
services->setPixelShaderConstant("FogMode", (int*)&fogType, 1);
#endif
}
}
void RealisticWaterSceneNode::setWindForce(const f32 windForce)
{
_windForce = windForce;
}
void RealisticWaterSceneNode::setWindDirection(const core::vector2df& windDirection)
{
_windDirection = windDirection;
_windDirection.normalize();
}
void RealisticWaterSceneNode::setWaveHeight(const f32 waveHeight)
{
_waveHeight = waveHeight;
}
void RealisticWaterSceneNode::setWaterColor(const video::SColorf& waterColor)
{
_waterColor = waterColor;
}
void RealisticWaterSceneNode::setColorBlendFactor(const f32 colorBlendFactor)
{
_colorBlendFactor = colorBlendFactor;
}

92
rcbasic_runtime/RealisticWater.h Executable file
View File

@@ -0,0 +1,92 @@
/*
* Copyright (c) 2013, elvman
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY elvman ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _REALISTIC_WATER_SCENE_NODE_H
#define _REALISTIC_WATER_SCENE_NODE_H
#include <irrlicht.h>
using namespace irr;
class RealisticWaterSceneNode: public scene::ISceneNode, video::IShaderConstantSetCallBack
{
public:
RealisticWaterSceneNode(scene::ISceneManager* sceneManager, f32 width, f32 height,
const irr::core::stringc& resourcePath = irr::core::stringc(),
core::dimension2du renderTargetSize=core::dimension2du(512,512),scene::ISceneNode* parent = NULL, s32 id = -1);
virtual ~RealisticWaterSceneNode();
// frame
virtual void OnRegisterSceneNode();
virtual void OnAnimate(u32 timeMs);
// renders terrain
virtual void render();
// returns the axis aligned bounding box of terrain
virtual const core::aabbox3d<f32>& getBoundingBox() const;
virtual void OnSetConstants(video::IMaterialRendererServices* services, s32 userData);
void setWindForce(f32 windForce);
void setWindDirection(const core::vector2df& windDirection);
void setWaveHeight(f32 waveHeight);
void setWaterColor(const video::SColorf& waterColor);
void setColorBlendFactor(f32 colorBlendFactor);
f32 getWindForce() { return _windForce; };
core::vector2df getWindDirection() { return _windDirection; };
f32 getWaveHeight() { return _waveHeight; };
video::SColorf getWaterColor() { return _waterColor; };
f32 getColorBlendFactor() { return _colorBlendFactor; };
private:
scene::ICameraSceneNode* _camera;
scene::ISceneNode* _waterSceneNode;
video::IVideoDriver* _videoDriver;
scene::ISceneManager* _sceneManager;
core::dimension2d<f32> _size;
s32 _shaderMaterial;
scene::IAnimatedMesh* _waterMesh;
video::ITexture* _refractionMap;
video::ITexture* _reflectionMap;
f32 _windForce;
core::vector2df _windDirection;
f32 _waveHeight;
video::SColorf _waterColor;
f32 _colorBlendFactor;
u32 _time;
};
#endif

22
rcbasic_runtime/main.cpp
View File

@@ -48,9 +48,13 @@
#include <iomanip>
#include "rc_defines.h"
#include "rc_stdlib.h"
#include "rc_gfx.h"
#include "rc_gfx.h"
#include "rc_gfx3D.h"
#include "rc_matrix.h"
#include "rc_geometry.h"
#include "rc_audio.h"
#include "rc_net.h"
#include "rc_video.h"
#include <irrtheora.h>
@@ -4310,16 +4314,18 @@ bool rcbasic_run()
}
void rcbasic_init()
{
for(int i = 0; i < RC_MAX_FILES; i++)
rc_fstream[i] = NULL;
rc_media_init();
{
rc_audio_init();
rc_gfx_init();
rc_net_init();
arr_ref_id.clear();
}
void rcbasic_clean()
{
rc_media_quit();
rc_audio_quit();
rc_net_quit();
rc_gfx_quit();
byref_addr_table.empty();
loop_stack.empty();
n_stack.empty();
@@ -4411,7 +4417,7 @@ int main(int argc, char * argv[])
}
rcbasic_init();
rc_initSubprocessSystem();
//rc_initSubprocessSystem();
if(rc_filename.length()>=4)
{
@@ -4465,7 +4471,7 @@ int main(int argc, char * argv[])
else
cout << "++Could not load rcbasic program" << endl;
rc_cleanSubprocessSystem();
//rc_cleanSubprocessSystem();
rcbasic_clean();
exit(rcbasic_exit_code);

393
rcbasic_runtime/rc_audio.h Normal file
View File

@@ -0,0 +1,393 @@
#ifndef RC_AUDIO_H_INCLUDED
#define RC_AUDIO_H_INCLUDED
#include <vector>
#include "rc_os_defines.h"
#ifdef RC_ANDROID
#define RC_MOBILE
#endif
#ifdef RC_IOS
#define RC_MOBILE
#endif
#ifdef RC_ANDROID
#include <android/log.h>
//Using SDL and standard IO
#include <string>
#include <stdio.h>
#include <iostream>
#include "SDL.h"
#include "SDL_mixer.h"
#else
#ifdef RC_IOS
//Using SDL and standard IO
#include <string>
#include <stdio.h>
#include <iostream>
#include "SDL2/SDL.h"
#include "SDL2/SDL_mixer.h"
#else
//Using SDL and standard IO
#include <string>
#include <sstream>
#include <stdio.h>
#include <iostream>
#include <SDL2/SDL.h>
#include <SDL2/SDL_mixer.h>
#endif //RC_IOS
#endif // RC_ANDROID
using namespace std;
#ifdef RC_MOBILE
//Screen dimension constants
const int MAX_SOUNDS = 1024;
const int MAX_MUSIC = 1;
#else
//Screen dimension constants
const int MAX_SOUNDS = 1024;
const int MAX_MUSIC = 1;
#endif // RC_MOBILE
struct rc_sound_obj
{
Mix_Chunk * sound;
bool active = false;
};
std::vector<rc_sound_obj> rc_sound;
Mix_Music * rc_music;
bool rc_audio_init()
{
if(Mix_OpenAudio(MIX_DEFAULT_FREQUENCY, MIX_DEFAULT_FORMAT, 2, 2048) < 0)
{
cout << "OpenAudio Error: " << Mix_GetError() << endl;
return false;
}
return true;
}
bool rc_audio_quit()
{
for(int i = 0; i < rc_sound.size(); i++)
{
if(rc_sound[i].sound != NULL)
Mix_FreeChunk(rc_sound[i].sound);
rc_sound[i].sound = NULL;
}
if(rc_music != NULL)
Mix_FreeMusic(rc_music);
rc_music = NULL;
Mix_Quit();
return true;
}
int rc_queryAudioSpec(double * freq, double * format, double * channels)
{
//need to do something here
int qa_freq = 0;
Uint16 qa_format = 0;
int qa_channels = 0;
int result = Mix_QuerySpec(&qa_freq, &qa_format, &qa_channels);
*freq = (double)qa_freq;
*format = (double)qa_format;
*channels = (double)qa_channels;
return result;
}
int rc_loadSound(std::string fname)
{
int id = -1;
for(int i = 0; i < rc_sound.size(); i++)
{
if(!rc_sound[i].active)
{
id = i;
break;
}
}
if(id < 0)
{
rc_sound_obj obj;
id = rc_sound.size();
rc_sound.push_back(obj);
}
rc_sound[id].sound = Mix_LoadWAV(fname.c_str());
if(rc_sound[id].sound == NULL)
{
std::cout << "Could not load sound: " << Mix_GetError() << std::endl;
return -1;
}
rc_sound[id].active = true;
return id;
}
int rc_createSound(double * abuf, Uint32 alen, Uint8 volume)
{
int id = -1;
for(int i = 0; i < rc_sound.size(); i++)
{
if(!rc_sound[i].active)
{
id = i;
break;
}
}
if(id < 0)
{
rc_sound_obj obj;
id = rc_sound.size();
rc_sound.push_back(obj);
}
rc_sound[id].sound = (Mix_Chunk*)SDL_malloc(sizeof(Mix_Chunk));
rc_sound[id].sound->allocated = 1;
rc_sound[id].sound->abuf = (Uint8*)SDL_malloc(sizeof(Uint8)*alen);
for(int i = 0; i < alen; i++)
rc_sound[id].sound->abuf[i] = (Uint8)abuf[i];
rc_sound[id].sound->alen = alen;
rc_sound[id].sound->volume = volume;
rc_sound[id].active = true;
return id;
}
void rc_loadMusic(std::string fname)
{
if(rc_music != NULL)
{
Mix_FreeMusic(rc_music);
}
rc_music = Mix_LoadMUS(fname.c_str());
if(rc_music == NULL)
{
std::cout << "Could not load music: " << Mix_GetError() << std::endl;
return;
}
}
void rc_deleteMusic()
{
if(rc_music)
{
Mix_FreeMusic(rc_music);
rc_music = NULL;
}
}
void rc_playSound(int slot, int channel, int loops)
{
if(rc_sound[slot].sound != NULL)
{
Mix_PlayChannel(channel, rc_sound[slot].sound, loops);
}
}
void rc_playSoundTimed(int slot, int channel, int loops, int ms)
{
if(rc_sound[slot].sound != NULL)
{
Mix_PlayChannelTimed(channel, rc_sound[slot].sound, loops, ms);
}
}
void rc_playMusic(int loops)
{
if(rc_music != NULL)
{
Mix_PlayMusic(rc_music, loops);
}
}
int rc_musicIsPlaying()
{
if(rc_music != NULL)
{
return Mix_PlayingMusic();
}
return 0;
}
void rc_pauseSound(int channel)
{
if(Mix_Playing(channel))
{
Mix_Pause(channel);
}
}
void rc_resumeSound(int channel)
{
if(!Mix_Playing(channel))
{
Mix_Resume(channel);
}
}
void rc_pauseMusic()
{
if(Mix_PlayingMusic())
{
Mix_PauseMusic();
}
}
void rc_resumeMusic()
{
if(!Mix_PlayingMusic())
{
Mix_ResumeMusic();
}
}
void rc_deleteSound(int slot)
{
if(rc_sound[slot].sound != NULL)
{
Mix_FreeChunk(rc_sound[slot].sound);
rc_sound[slot].sound = NULL;
}
rc_sound[slot].active = false;
}
void rc_fadeMusicIn(int time, int loops)
{
Mix_FadeInMusic(rc_music, loops, time);
}
void rc_fadeMusicOut(int time)
{
Mix_FadeOutMusic(time);
}
bool rc_musicExists()
{
if(rc_music != NULL)
return true;
return false;
}
void rc_setMusicVolume(int volume)
{
Mix_VolumeMusic(volume);
}
int rc_getMusicVolume()
{
return Mix_VolumeMusic(-1);
}
void rc_setMusicPosition(double position)
{
Mix_SetMusicPosition(position);
}
double rc_getMusicPosition()
{
return Mix_SetMusicPosition(-1);
}
void rc_rewindMusic()
{
Mix_RewindMusic();
}
void rc_setSoundChannels(int max_channels)
{
Mix_AllocateChannels(max_channels);
}
int rc_getSoundChannels()
{
return Mix_AllocateChannels(-1);
}
bool rc_soundIsEnabled()
{
return (bool) Mix_Init(0);
}
bool rc_soundExists(int slot)
{
return rc_sound[slot].active;
}
void rc_setChannelVolume(int channel, int volume)
{
Mix_Volume(channel, volume);
}
int rc_getChannelVolume(int channel)
{
return Mix_Volume(channel, -1);
}
void rc_setSoundVolume(int slot, int volume)
{
Mix_VolumeChunk(rc_sound[slot].sound, volume);
}
int rc_getSoundVolume(int slot)
{
return Mix_VolumeChunk(rc_sound[slot].sound, -1);
}
void rc_stopMusic()
{
Mix_HaltMusic();
}
void rc_stopSound(int channel)
{
Mix_HaltChannel(channel);
}
int rc_channelIsPlaying(int channel)
{
return Mix_Playing(channel);
}
int rc_channelIsPaused(int channel)
{
return Mix_Paused(channel);
}
int rc_setChannelDistance(int channel, Uint8 dist)
{
return Mix_SetDistance(channel, dist);
}
int rc_setChannelPanning(int channel, Uint8 l, Uint8 r)
{
return Mix_SetPanning(channel, l, r);
}
int rc_setChannelSpacePosition(int channel, double angle, double distance)
{
return Mix_SetPosition(channel, (Sint16)angle, (Uint8) distance);
}
#endif // RC_AUDIO_H_INCLUDED

1056
rcbasic_runtime/rc_defines.h
View File

File diff suppressed because it is too large Load Diff

577
rcbasic_runtime/rc_func130_cases.h
View File

File diff suppressed because it is too large Load Diff

141
rcbasic_runtime/rc_geometry.h
View File

@@ -8,127 +8,6 @@
// ------------------ 3D Transform Routines --------------------------------
double CalculateFaceZ(double cam_dist, double graph_offset_x, double graph_offset_y, double view_w, double view_h, double view_depth, uint32_t mA, int f_vertex_count, double* columns, double* face_min_z, double* face_max_z, double* z_avg)
{
bool dbg = false;
if(f_vertex_count > 4)
return -1;
double vx, vy, vz[4];
int oi_count = 0;
double n_face_min_z = MatrixValue(mA, 2, (uint32_t)columns[0]);
double n_face_max_z = n_face_min_z;
bool in_zx_range = false;
bool in_zy_range = false;
double face_min_x = 0;
double face_max_x = 0;
double face_min_y = 0;
double face_max_y = 0;
bool zx_min_bound = false;
bool zx_max_bound = false;
bool zy_min_bound = false;
bool zy_max_bound = false;
double distance = 0;
double z_dist = 0; //C3D_CAMERA_LENS - z
double off_x = graph_offset_x;
double off_y = graph_offset_y;
double min_x = (0 - off_x) / cam_dist;
double min_y = (view_h - off_y) / cam_dist * -1;
double max_x = (view_w - off_x) / cam_dist;
double max_y = (0 - off_y) / cam_dist * -1;
double zx_min, zx_max, zy_min, zy_max;
for(int i = 0; i < f_vertex_count; i++)
{
vz[i] = MatrixValue(mA, 2, (uint32_t)columns[i]);
vx = MatrixValue(mA, 0, (uint32_t)columns[i]);
vy = MatrixValue(mA, 1, (uint32_t)columns[i]);
distance = -1*vz[i];
if(distance >= 0 && distance < view_depth)
{
double d = cam_dist - (distance*-1);
zx_min = min_x * d;
zx_max = max_x * d;
zy_min = min_y * d;
zy_max = max_y * d;
in_zx_range = in_zx_range || (vx >= zx_min && vx < zx_max);
in_zy_range = in_zy_range || (vy >= zy_min && vy < zy_max);
zx_min_bound = zx_min_bound || (vx < zx_min);
zx_max_bound = zx_max_bound || (vx >= zx_max);
zy_min_bound = zy_min_bound || (vy < zy_min);
zy_max_bound = zy_max_bound || (vy >= zy_max);
}
else if(vz[i] >= 0 && vz[i] < view_depth)
{
double d = cam_dist - (vz[i]*-1);
zx_min = min_x * d;
zx_max = max_x * d;
zy_min = min_y * d;
zy_max = max_y * d;
in_zx_range = in_zx_range || (vx >= zx_min && vx < zx_max);
in_zy_range = in_zy_range || (vy >= zy_min && vy < zy_max);
zx_min_bound = zx_min_bound || (vx < zx_min);
zx_max_bound = zx_max_bound || (vx >= zx_max);
zy_min_bound = zy_min_bound || (vy < zy_min);
zy_max_bound = zy_max_bound || (vy >= zy_max);
}
n_face_min_z = min(n_face_min_z, vz[i]);
n_face_max_z = max(n_face_max_z, vz[i]);
}
in_zx_range = in_zx_range || (zx_min_bound && zx_max_bound);
in_zy_range = in_zy_range || (zy_min_bound && zy_max_bound);
if( (!in_zx_range) || (!in_zy_range) )
return -1;
//'if key(k_i) and actor = 1 then : print "face = ";face_num : end if
z_avg[0] = (n_face_min_z+n_face_max_z) / 2; //'This is some bullshit math to order the faces with out checking if they are obscured
face_min_z[0] = n_face_min_z;
face_max_z[0] = n_face_max_z;
//C3D_Actor_Face_ZOrder[actor, face_num] = face_min_z
if(face_min_z[0] >= cam_dist)
return -1;
else
return (cam_dist - face_min_z[0]);
}
int GetLinePlaneIntersection(double* line_point, double* line_direction, double* plane_point_1, double* plane_point_2, double* plane_point_3, double* intersection)
{
//' """
@@ -796,26 +675,6 @@ void projectionGeometry(int cam_dist, int f_vertex_count, double* vertex3D, doub
}
void rc_GetProjectionGeometry(int cam_dist, uint32_t mA, int f_vertex_count, double* columns, double* uv, double graph_offset_x, double graph_offset_y, uint32_t color,
double* vertex_count, double* vertex2D, double* ind_count, double* index, double* clip_dist, double* min_x, double* min_y, double* max_x, double* max_y)
{
double vertex3D[18]; // number of vertices * 3 -> ie. (x,y,z) for each vertex
int v_index = 0;
for(int i = 0; i < f_vertex_count; i++)
{
vertex3D[v_index] = MatrixValue(mA, 0, columns[i]);
vertex3D[v_index+1] = MatrixValue(mA, 1, columns[i]);
vertex3D[v_index+2] = MatrixValue(mA, 2, columns[i]);
v_index += 3;
}
projectionGeometry(cam_dist, f_vertex_count, &vertex3D[0], uv, graph_offset_x, graph_offset_y, color,
vertex_count, vertex2D, ind_count, index, clip_dist, min_x, min_y, max_x, max_y);
}
// --------------------------------------------------------------------------

31
rcbasic_runtime/rc_gfx.h
View File

@@ -119,7 +119,7 @@ int mobile_event_filter(void* userdata, SDL_Event* evt)
}
bool rcbasic_init()
bool rc_gfx_init()
{
if(SDL_Init(SDL_INIT_EVENTS | SDL_INIT_TIMER | SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_SENSOR | SDL_INIT_NOPARACHUTE) < 0) //Audio causes init to fail on Fedora40 so I am leaving it out for now
{
@@ -210,6 +210,20 @@ bool rcbasic_init()
}
bool rc_gfx_quit()
{
irrtheora::stopVideo();
irrtheora::deleteVideo();
if(device)
device->drop();
SDL_Quit();
return true;
}
bool rc_windowOpenEx(std::string title, int x, int y, int w, int h, uint32_t window_flags, irr::u8 AntiAlias, bool stencil_buffer, bool vsync)
{
if(rc_window)
@@ -304,6 +318,9 @@ bool rc_windowOpen(std::string title, int w, int h, bool fullscreen, bool vsync)
void rc_closeWindow_hw()
{
irrtheora::stopVideo();
irrtheora::deleteVideo();
if(rc_window!=NULL)
SDL_DestroyWindow(rc_window);
rc_window = NULL;
@@ -969,7 +986,7 @@ void rc_setActiveCanvas(int canvas_id)
}
}
int rc_getActiveCanvas()
int rc_activeCanvas()
{
return rc_active_canvas;
}
@@ -1075,7 +1092,7 @@ void rc_setCanvasColorMod(int canvas_id, Uint32 color_mod)
}
}
Uint32 rc_canvasColorMod(int canvas_id)
Uint32 rc_getCanvasColorMod(int canvas_id)
{
if(canvas_id <= 0 || canvas_id >= rc_canvas.size()) //canvas 0 is being excluded because its the back buffer
return 0;
@@ -1124,7 +1141,7 @@ void rc_setCanvasZ(int canvas_id, int z)
sortCanvasZ();
}
int rc_canvasZ(int canvas_id)
int rc_getCanvasZ(int canvas_id)
{
if(canvas_id <= 0 || canvas_id >= rc_canvas.size()) //canvas 0 is being excluded because its the back buffer
return 0;
@@ -1711,7 +1728,7 @@ bool rc_mouseIsVisible()
}
int rc_inkey()
int rc_inKey()
{
return rc_inkey_val;
}
@@ -1856,7 +1873,7 @@ int rc_joyButton(int joy_num, int jbutton)
return 0;
}
std::string rc_joystickName(int joy_num)
std::string rc_joyName(int joy_num)
{
if(joy_num >= 0 && joy_num < MAX_JOYSTICKS)
return (std::string)SDL_JoystickName(rc_joystick[joy_num]);
@@ -3302,6 +3319,8 @@ bool rc_update()
SDL_Event SDL_event;
bool Close = false;
rc_inkey_val = 0;
while ( !Close && SDL_PollEvent( &SDL_event ) )
{
// os::Printer::log("event: ", core::stringc((int)SDL_event.type).c_str(), ELL_INFORMATION); // just for debugging

196
rcbasic_runtime/rc_matrix.h
View File

@@ -33,10 +33,6 @@ struct rc_matrix_type
std::vector<rc_matrix_type> rc_matrix(64);
#define RC_TMP_MATRIX 1024
#define RC_TMP_MATRIX_2 1025
#define RC_PROCESS_TMP_MATRIX_OFFSET 1026
#define NEW_MATRIX -1
@@ -90,8 +86,15 @@ int DimMatrix(int m, uint32_t m_rows, uint32_t m_cols, bool preserve_flag=false)
return m;
}
void DeleteMatrix(int mA)
int rc_dimMatrix(uint32_t m_rows, uint32_t m_cols)
{
return DimMatrix(NEW_MATRIX, m_rows, m_cols, false);
}
void rc_deleteMatrix(int mA)
{
if(mA < 0 || mA >= rc_matrix.size())
return;
rc_matrix[mA].data.clear();
rc_matrix[mA].c = 0;
rc_matrix[mA].r = 0;
@@ -99,7 +102,7 @@ void DeleteMatrix(int mA)
}
//Adds Matrix A() to Matrix B(), answer is Matrix C()
bool AddMatrix(int mA, int mB, int mC)
bool rc_addMatrix(int mA, int mB, int mC)
{
if( (rc_matrix[mA].r != rc_matrix[mB].r) || (rc_matrix[mA].c != rc_matrix[mB].c) )
{
@@ -123,7 +126,7 @@ bool AddMatrix(int mA, int mB, int mC)
}
//Concatenates matrix A() and B(), output is matrix C()
bool AugmentMatrix (int mA, int mB, int mC)
bool rc_augmentMatrix (int mA, int mB, int mC)
{
if(rc_matrix[mA].r != rc_matrix[mB].r)
{
@@ -159,7 +162,7 @@ bool AugmentMatrix (int mA, int mB, int mC)
}
//Copies contents of matrix A() to B()
void CopyMatrix(int mA, int mB)
void rc_copyMatrix(int mA, int mB)
{
DimMatrix(mB, rc_matrix[mA].r, rc_matrix[mA].c);
@@ -175,7 +178,7 @@ void CopyMatrix(int mA, int mB)
}
//Inserts specified number of columns in matrix A before c and shifts values to the right
bool InsertMatrixColumn(int mA, uint32_t c, uint32_t num_cols)
bool rc_insertMatrixColumns(int mA, uint32_t c, uint32_t num_cols)
{
if(c >= rc_matrix[mA].c)
{
@@ -214,7 +217,7 @@ bool InsertMatrixColumn(int mA, uint32_t c, uint32_t num_cols)
}
//Creates new zero row M% in matrix A(), moves values down
bool InsertMatrixRow (int mA, uint32_t r, uint32_t num_rows)
bool rc_insertMatrixRows(int mA, uint32_t r, uint32_t num_rows)
{
if(r >= rc_matrix[mA].r)
{
@@ -249,7 +252,7 @@ bool InsertMatrixRow (int mA, uint32_t r, uint32_t num_rows)
}
//Multiplies Matrix A() with Matrix B(), answer is Matrix C()
bool MultiplyMatrix (int mA, int mB, int mC)
bool rc_multiplyMatrix (int mA, int mB, int mC)
{
if( rc_matrix[mA].c != rc_matrix[mB].r )
{
@@ -283,7 +286,7 @@ bool MultiplyMatrix (int mA, int mB, int mC)
}
//Multiplies matrix A() * A() * A(), returns matrix B()
bool CubeMatrix(int mA, int mB, int process_num)
bool rc_cubeMatrix(int mA, int mB)
{
if(rc_matrix[mA].r != rc_matrix[mA].c)
{
@@ -291,19 +294,16 @@ bool CubeMatrix(int mA, int mB, int process_num)
return false;
}
int tmp_mat1 = process_num < 0 ? RC_TMP_MATRIX : (process_num*2) + RC_PROCESS_TMP_MATRIX_OFFSET;
//int tmp_mat2 = process_num < 0 ? RC_TMP_MATRIX : (process_num*2) + RC_PROCESS_TMP_MATRIX_OFFSET + 1;
int tmp_mat1 = DimMatrix(NEW_MATRIX, rc_matrix[mA].r, rc_matrix[mA].c);
rc_multiplyMatrix(mA, mA, tmp_mat1);
rc_multiplyMatrix(tmp_mat1, mA, mB);
DimMatrix(tmp_mat1, rc_matrix[mA].r, rc_matrix[mA].c);
MultiplyMatrix(mA, mA, tmp_mat1);
MultiplyMatrix(tmp_mat1, mA, mB);
DimMatrix(tmp_mat1, 1, 1);
rc_deleteMatrix(tmp_mat1);
return true;
}
// Deletes column N% from matrix
bool DeleteMatrixColumns(int mA, uint32_t c, uint32_t num_cols, int process_num)
bool rc_deleteMatrixColumns(int mA, uint32_t c, uint32_t num_cols)
{
if(c >= rc_matrix[mA].c)
{
@@ -314,10 +314,7 @@ bool DeleteMatrixColumns(int mA, uint32_t c, uint32_t num_cols, int process_num)
if((c + num_cols) > rc_matrix[mA].c)
num_cols = rc_matrix[mA].c - c;
int tmp_mat1 = process_num < 0 ? RC_TMP_MATRIX : (process_num*2) + RC_PROCESS_TMP_MATRIX_OFFSET;
//int tmp_mat2 = process_num < 0 ? RC_TMP_MATRIX : (process_num*2) + RC_PROCESS_TMP_MATRIX_OFFSET + 1;
DimMatrix( tmp_mat1, rc_matrix[mA].r, rc_matrix[mA].c - num_cols);
int tmp_mat1 = DimMatrix( NEW_MATRIX, rc_matrix[mA].r, rc_matrix[mA].c - num_cols);
uint32_t old_offset = 0;
uint32_t row_offset = 0;
@@ -335,13 +332,13 @@ bool DeleteMatrixColumns(int mA, uint32_t c, uint32_t num_cols, int process_num)
rc_matrix[tmp_mat1].data[row_offset + col] = rc_matrix[mA].data[old_offset + col];
}
}
CopyMatrix(tmp_mat1, mA);
DimMatrix(tmp_mat1, 1, 1);
rc_copyMatrix(tmp_mat1, mA);
rc_deleteMatrix(tmp_mat1);
return true;
}
//Deletes row M% from matrix
bool DeleteMatrixRows(int mA, uint32_t r, uint32_t num_rows)
bool rc_deleteMatrixRows(int mA, uint32_t r, uint32_t num_rows)
{
if(r >= rc_matrix[mA].r)
{
@@ -373,14 +370,14 @@ bool DeleteMatrixRows(int mA, uint32_t r, uint32_t num_rows)
}
//Clears contents of matrix A()
void ClearMatrix(int mA)
void rc_clearMatrix(int mA)
{
for(int i = 0; i < rc_matrix[mA].data.size(); i++)
rc_matrix[mA].data[i] = 0;
}
//Fills column J% of matrix A() with zeros
bool ClearMatrixColumns (int mA, uint32_t c, uint32_t num_cols)
bool rc_clearMatrixColumns (int mA, uint32_t c, uint32_t num_cols)
{
if(c >= rc_matrix[mA].c)
{
@@ -403,7 +400,7 @@ bool ClearMatrixColumns (int mA, uint32_t c, uint32_t num_cols)
}
// Fills row I% of matrix A() with zeros
bool ClearMatrixRows(int mA, uint32_t r, uint32_t num_rows)
bool rc_clearMatrixRows(int mA, uint32_t r, uint32_t num_rows)
{
if(r >= rc_matrix[mA].r)
{
@@ -429,14 +426,14 @@ bool ClearMatrixRows(int mA, uint32_t r, uint32_t num_rows)
}
// Fills matrix A() with value V
void FillMatrix(int mA, double v)
void rc_fillMatrix(int mA, double v)
{
for(uint32_t i = 0; i < rc_matrix[mA].data.size(); i++)
rc_matrix[mA].data[i] = v;
}
// Fills matrix A() column J% with value V
bool FillMatrixColumns(int mA, uint32_t c, uint32_t num_cols, double v)
bool rc_fillMatrixColumns(int mA, uint32_t c, uint32_t num_cols, double v)
{
if(c >= rc_matrix[mA].c)
{
@@ -459,7 +456,7 @@ bool FillMatrixColumns(int mA, uint32_t c, uint32_t num_cols, double v)
}
// Fills matrix A() row I% with value V
bool FillMatrixRows(int mA, uint32_t r, uint32_t num_rows, double v)
bool rc_fillMatrixRows(int mA, uint32_t r, uint32_t num_rows, double v)
{
if(r >= rc_matrix[mA].r)
{
@@ -485,7 +482,7 @@ bool FillMatrixRows(int mA, uint32_t r, uint32_t num_rows, double v)
}
// Copies A() column J% to column matrix B()
bool GetMatrixColumns(uint32_t mA, uint32_t mB, uint32_t c, uint32_t num_cols)
bool rc_copyMatrixColumns(uint32_t mA, uint32_t mB, uint32_t c, uint32_t num_cols)
{
if(c >= rc_matrix[mA].c)
{
@@ -512,7 +509,7 @@ bool GetMatrixColumns(uint32_t mA, uint32_t mB, uint32_t c, uint32_t num_cols)
}
// Copies A() row I% to row matrix B()
bool GetMatrixRows (uint32_t mA, uint32_t mB, uint32_t r, uint32_t num_rows)
bool rc_copyMatrixRows (uint32_t mA, uint32_t mB, uint32_t r, uint32_t num_rows)
{
if(r > rc_matrix[mA].r)
@@ -542,7 +539,7 @@ bool GetMatrixRows (uint32_t mA, uint32_t mB, uint32_t r, uint32_t num_rows)
}
// Creates Identity Matrix A() of order N%
void setIdentityMatrix(uint32_t mA, uint32_t n)
void rc_setIdentityMatrix(uint32_t mA, uint32_t n)
{
DimMatrix(mA, n, n);
for(int i = 0; i < n; i++)
@@ -576,7 +573,7 @@ bool GaussianElimination(vector< vector<double> > &A, vector<double> &b, uint32_
vector<double> x(n);
DimMatrix(mC, n, 1);
ClearMatrix(mC);
rc_clearMatrix(mC);
for (int i = n - 1; i >= 0; i--) {
double sum = 0.0;
@@ -593,7 +590,7 @@ bool GaussianElimination(vector< vector<double> > &A, vector<double> &b, uint32_
// Solve the system that has A as coefficient matrix and B is the right hand side of the equation
// Solution will be stored in C
bool SolveMatrix(uint32_t mA, uint32_t mB, uint32_t mC)
bool rc_solveMatrix(uint32_t mA, uint32_t mB, uint32_t mC)
{
if(rc_matrix[mA].r != rc_matrix[mA].c || rc_matrix[mA].r != rc_matrix[mB].r || rc_matrix[mB].c != 1)
return false;
@@ -623,7 +620,7 @@ double d_abs(double n)
}
//Determines if matrix A() is equal (within Tol constant) to matrix B()
bool IsEqualMatrix(uint32_t mA, uint32_t mB, double tolerance)
bool rc_isEqualMatrix(uint32_t mA, uint32_t mB, double tolerance)
{
if( (rc_matrix[mA].r != rc_matrix[mB].r) || (rc_matrix[mA].c != rc_matrix[mB].c) )
return false;
@@ -669,7 +666,7 @@ void getCofactor(uint32_t A_dim, double* A, double* temp, int p, int q,
}
}
void CofactorMatrix(uint32_t mA, int p, int q, int n)
void rc_cofactorMatrix(uint32_t mA, int p, int q, int n)
{
uint32_t m_size = rc_matrix[mA].c;
@@ -716,13 +713,13 @@ double determinant(double* A, int n, uint32_t m_size)
return D;
}
double Determinant(uint32_t mA)
double rc_determinant(uint32_t mA)
{
uint32_t m_size = rc_matrix[mA].r;
if(rc_matrix[mA].c != m_size)
{
cout << "Determinant Error: matrix must be square" << endl;
return false;
return 0;
}
return determinant(rc_matrix[mA].data.data(), m_size, m_size);
}
@@ -756,7 +753,7 @@ void adjoint(double* A, double* adj, uint32_t n, uint32_t m_size)
}
}
bool AdjointMatrix(uint32_t mA, uint32_t mB)
bool rc_adjointMatrix(uint32_t mA, uint32_t mB)
{
uint32_t m_size = rc_matrix[mA].r;
if(rc_matrix[mA].c != m_size)
@@ -792,7 +789,7 @@ bool inverse(double* A, double* inv, uint32_t n)
return true;
}
bool InvertMatrix(uint32_t mA, uint32_t mB)
bool rc_invertMatrix(uint32_t mA, uint32_t mB)
{
uint32_t m_size = rc_matrix[mA].r;
if(rc_matrix[mA].c != m_size)
@@ -811,7 +808,7 @@ bool InvertMatrix(uint32_t mA, uint32_t mB)
//Loads contents of FileName$ into matrix A()
void MatrixFromBuffer(uint32_t mA, uint32_t r, uint32_t c, double* buffer)
void rc_matrixFromBuffer(uint32_t mA, uint32_t r, uint32_t c, double* buffer)
{
uint32_t row_offset = 0;
DimMatrix(mA, r, c);
@@ -827,7 +824,7 @@ void MatrixFromBuffer(uint32_t mA, uint32_t r, uint32_t c, double* buffer)
}
//Loads contents of FileName$ into matrix A()
void BufferFromMatrix(double* buffer, uint32_t mA)
void rc_bufferFromMatrix(double* buffer, uint32_t mA)
{
uint32_t row_offset = 0;
for(uint32_t row = 0; row < rc_matrix[mA].r; row++)
@@ -841,7 +838,7 @@ void BufferFromMatrix(double* buffer, uint32_t mA)
}
//Fills matrix A() with random values ranging from VMin to VMax
void RandomizeMatrix(uint32_t mA, double vmin, double vmax)
void rc_randomizeMatrix(uint32_t mA, double vmin, double vmax)
{
uint32_t row_offset = 0;
for(uint32_t row = 0; row < rc_matrix[mA].r; row++)
@@ -855,7 +852,7 @@ void RandomizeMatrix(uint32_t mA, double vmin, double vmax)
}
//get value from matrix A
double MatrixValue(uint32_t mA, uint32_t r, uint32_t c)
double rc_matrixValue(uint32_t mA, uint32_t r, uint32_t c)
{
uint32_t pos = r*rc_matrix[mA].c + c;
if(pos >= rc_matrix[mA].data.size())
@@ -865,7 +862,7 @@ double MatrixValue(uint32_t mA, uint32_t r, uint32_t c)
}
//set value at (r, c) in matrix
void SetMatrixValue(uint32_t mA, uint32_t r, uint32_t c, double v)
void rc_setMatrixValue(uint32_t mA, uint32_t r, uint32_t c, double v)
{
uint32_t pos = r*rc_matrix[mA].c + c;
if(pos >= rc_matrix[mA].data.size())
@@ -875,7 +872,7 @@ void SetMatrixValue(uint32_t mA, uint32_t r, uint32_t c, double v)
}
//Multiplies matrix A() by scalar, output matrix B()
void ScalarMatrix (uint32_t mA, uint32_t mB, double s_value)
void rc_scalarMatrix (uint32_t mA, uint32_t mB, double s_value)
{
uint32_t row_offset = 0;
DimMatrix(mB, rc_matrix[mA].r, rc_matrix[mA].c);
@@ -890,7 +887,7 @@ void ScalarMatrix (uint32_t mA, uint32_t mB, double s_value)
}
// Multiplies matrix A() by scalar S at column J%, output matrix B()
bool ScalarMatrixColumns(uint32_t mA, uint32_t mB, uint32_t c, uint32_t num_cols, double s_value)
bool rc_scalarMatrixColumns(uint32_t mA, uint32_t mB, uint32_t c, uint32_t num_cols, double s_value)
{
if(c >= rc_matrix[mA].c)
{
@@ -901,7 +898,7 @@ bool ScalarMatrixColumns(uint32_t mA, uint32_t mB, uint32_t c, uint32_t num_cols
if( (c+num_cols) >= rc_matrix[mA].c)
num_cols = rc_matrix[mA].c - c;
CopyMatrix(mA, mB);
rc_copyMatrix(mA, mB);
int row_offset = 0;
int b_offset = 0;
@@ -916,7 +913,7 @@ bool ScalarMatrixColumns(uint32_t mA, uint32_t mB, uint32_t c, uint32_t num_cols
}
//Multiplies matrix A() by scalar S at row I%, output matrix B()
bool ScalarMatrixRows(uint32_t mA, uint32_t mB, uint32_t r, uint32_t num_rows, double s_value)
bool rc_scalarMatrixRows(uint32_t mA, uint32_t mB, uint32_t r, uint32_t num_rows, double s_value)
{
if(r > rc_matrix[mA].r)
@@ -928,7 +925,7 @@ bool ScalarMatrixRows(uint32_t mA, uint32_t mB, uint32_t r, uint32_t num_rows, d
if( (r+num_rows) > rc_matrix[mA].r)
num_rows = rc_matrix[mA].r - r;
CopyMatrix(mA, mB);
rc_copyMatrix(mA, mB);
uint32_t row_offset = 0;
@@ -946,7 +943,7 @@ bool ScalarMatrixRows(uint32_t mA, uint32_t mB, uint32_t r, uint32_t num_rows, d
}
// Multiplies matrix A() * A(), returns matrix B()
bool SquareMatrix(uint32_t mA, uint32_t mB)
bool rc_squareMatrix(uint32_t mA, uint32_t mB)
{
if(rc_matrix[mA].r != rc_matrix[mA].c)
{
@@ -954,17 +951,17 @@ bool SquareMatrix(uint32_t mA, uint32_t mB)
return false;
}
return MultiplyMatrix(mA, mA, mB);
return rc_multiplyMatrix(mA, mA, mB);
}
// Deletes row r and column c from matrix A
void SubMatrix(uint32_t mA, uint32_t r, uint32_t c)
void rc_subMatrix(uint32_t mA, uint32_t r, uint32_t c)
{
CofactorMatrix(mA, r, c, rc_matrix[mA].c);
rc_cofactorMatrix(mA, r, c, rc_matrix[mA].c);
}
// Subtracts Matrix B() from Matrix A(), answer is Matrix C()
bool SubtractMatrix (uint32_t mA, uint32_t mB, uint32_t mC)
bool rc_subtractMatrix (uint32_t mA, uint32_t mB, uint32_t mC)
{
if(rc_matrix[mA].r != rc_matrix[mB].r || rc_matrix[mA].c != rc_matrix[mB].c)
{
@@ -988,20 +985,17 @@ bool SubtractMatrix (uint32_t mA, uint32_t mB, uint32_t mC)
}
// Swaps contents of Matrix A() with Matrix B()
void SwapMatrix(uint32_t mA, uint32_t mB, int process_num)
void rc_swapMatrix(uint32_t mA, uint32_t mB)
{
int tmp_mat1 = process_num < 0 ? RC_TMP_MATRIX : (process_num*2) + RC_PROCESS_TMP_MATRIX_OFFSET;
//int tmp_mat2 = process_num < 0 ? RC_TMP_MATRIX : (process_num*2) + RC_PROCESS_TMP_MATRIX_OFFSET + 1;
DimMatrix(tmp_mat1, rc_matrix[mA].r, rc_matrix[mA].c);
CopyMatrix(mB, tmp_mat1);
CopyMatrix(mA, mB);
CopyMatrix(tmp_mat1, mA);
DimMatrix(tmp_mat1, 1, 1);
int tmp_mat1 = DimMatrix(NEW_MATRIX, rc_matrix[mA].r, rc_matrix[mA].c);
rc_copyMatrix(mB, tmp_mat1);
rc_copyMatrix(mA, mB);
rc_copyMatrix(tmp_mat1, mA);
rc_deleteMatrix(tmp_mat1);
}
// Swaps columns C1% and C2% in matrix A()
bool SwapMatrixColumn(uint32_t mA, uint32_t C1, uint32_t C2)
bool rc_swapMatrixColumn(uint32_t mA, uint32_t C1, uint32_t C2)
{
if(C1 >= rc_matrix[mA].c || C2 >= rc_matrix[mA].c)
{
@@ -1024,7 +1018,7 @@ bool SwapMatrixColumn(uint32_t mA, uint32_t C1, uint32_t C2)
}
// Swaps rows R1% and R2% in matrix A()
bool SwapMatrixRow(uint32_t mA, uint32_t R1, uint32_t R2)
bool rc_swapMatrixRow(uint32_t mA, uint32_t R1, uint32_t R2)
{
if(R1 >= rc_matrix[mA].r || R2 >= rc_matrix[mA].r)
{
@@ -1047,7 +1041,7 @@ bool SwapMatrixRow(uint32_t mA, uint32_t R1, uint32_t R2)
}
// Transposes matrix A(), output matrix B()
bool TransposeMatrix(uint32_t mA, uint32_t mB)
bool rc_transposeMatrix(uint32_t mA, uint32_t mB)
{
DimMatrix(mB, rc_matrix[mA].c, rc_matrix[mA].r);
@@ -1067,7 +1061,7 @@ bool TransposeMatrix(uint32_t mA, uint32_t mB)
// Splits matrix A() into square Coefficient B() and remaining Augment C()
bool UnAugmentMatrix(uint32_t mA, uint32_t mB, uint32_t mC)
bool rc_unAugmentMatrix(uint32_t mA, uint32_t mB, uint32_t mC)
{
if(rc_matrix[mA].c <= rc_matrix[mA].r)
{
@@ -1110,18 +1104,18 @@ bool UnAugmentMatrix(uint32_t mA, uint32_t mB, uint32_t mC)
// Clears contents of matrix A().
void ZeroMatrix (uint32_t mA)
void rc_zeroMatrix (uint32_t mA)
{
ClearMatrix(mA);
rc_clearMatrix(mA);
}
void GetMatrixSize(uint32_t mA, double* r, double* c)
void rc_getMatrixSize(uint32_t mA, double* r, double* c)
{
*r = rc_matrix[mA].r;
*c = rc_matrix[mA].c;
}
void IncrementMatrixRows(uint32_t mA, uint32_t mB, uint32_t r, uint32_t num_rows, double value)
void rc_incrementMatrixRows(uint32_t mA, uint32_t mB, uint32_t r, uint32_t num_rows, double value)
{
if(num_rows < 0)
return;
@@ -1132,19 +1126,19 @@ void IncrementMatrixRows(uint32_t mA, uint32_t mB, uint32_t r, uint32_t num_rows
if( (r+num_rows) >= rc_matrix[mA].r )
num_rows = rc_matrix[mA].r - r;
CopyMatrix(mA, mB);
rc_copyMatrix(mA, mB);
for(int mr = r; mr < (r+num_rows); mr++)
{
for(int mc = 0; mc < rc_matrix[mA].c; mc++)
{
double mv = MatrixValue(mA, mr, mc) + value;
SetMatrixValue(mB, mr, mc, mv);
double mv = rc_matrixValue(mA, mr, mc) + value;
rc_setMatrixValue(mB, mr, mc, mv);
}
}
}
void IncrementMatrixColumns(uint32_t mA, uint32_t mB, uint32_t c, uint32_t num_cols, double value)
void rc_incrementMatrixColumns(uint32_t mA, uint32_t mB, uint32_t c, uint32_t num_cols, double value)
{
if(num_cols < 0)
return;
@@ -1155,19 +1149,19 @@ void IncrementMatrixColumns(uint32_t mA, uint32_t mB, uint32_t c, uint32_t num_c
if( (c+num_cols) >= rc_matrix[mA].c )
num_cols = rc_matrix[mA].c - c;
CopyMatrix(mA, mB);
rc_copyMatrix(mA, mB);
for(int mr = 0; mr < rc_matrix[mA].r; mr++)
{
for(int mc = c; mc < (c+num_cols); mc++)
{
double mv = MatrixValue(mA, mr, mc) + value;
SetMatrixValue(mB, mr, mc, mv);
double mv = rc_matrixValue(mA, mr, mc) + value;
rc_setMatrixValue(mB, mr, mc, mv);
}
}
}
void JoinMatrixRows(uint32_t mA, uint32_t mB, uint32_t mC)
void rc_joinMatrixRows(uint32_t mA, uint32_t mB, uint32_t mC)
{
if(rc_matrix[mA].r != rc_matrix[mB].r)
return;
@@ -1181,8 +1175,8 @@ void JoinMatrixRows(uint32_t mA, uint32_t mB, uint32_t mC)
{
for(int r = 0; r < num_rows; r++)
{
double mv = MatrixValue(mA, r, c);
SetMatrixValue(mC, r, c, mv);
double mv = rc_matrixValue(mA, r, c);
rc_setMatrixValue(mC, r, c, mv);
}
}
@@ -1190,13 +1184,13 @@ void JoinMatrixRows(uint32_t mA, uint32_t mB, uint32_t mC)
{
for(int r = 0; r < num_rows; r++)
{
double mv = MatrixValue(mB, r, c);
SetMatrixValue(mC, r, rc_matrix[mA].c + c, mv);
double mv = rc_matrixValue(mB, r, c);
rc_setMatrixValue(mC, r, rc_matrix[mA].c + c, mv);
}
}
}
void JoinMatrixColumns(uint32_t mA, uint32_t mB, uint32_t mC)
void rc_joinMatrixColumns(uint32_t mA, uint32_t mB, uint32_t mC)
{
if(rc_matrix[mA].c != rc_matrix[mB].c)
return;
@@ -1210,8 +1204,8 @@ void JoinMatrixColumns(uint32_t mA, uint32_t mB, uint32_t mC)
{
for(int r = 0; r < rc_matrix[mA].r; r++)
{
double mv = MatrixValue(mA, r, c);
SetMatrixValue(mC, r, c, mv);
double mv = rc_matrixValue(mA, r, c);
rc_setMatrixValue(mC, r, c, mv);
}
}
@@ -1219,15 +1213,15 @@ void JoinMatrixColumns(uint32_t mA, uint32_t mB, uint32_t mC)
{
for(int r = 0; r < rc_matrix[mB].r; r++)
{
double mv = MatrixValue(mB, r, c);
SetMatrixValue(mC, rc_matrix[mA].r + r, c, mv);
double mv = rc_matrixValue(mB, r, c);
rc_setMatrixValue(mC, rc_matrix[mA].r + r, c, mv);
}
}
}
void ClipMatrix(int mA, int r, int c, int num_rows, int num_cols, int mB)
void rc_clipMatrix(int mA, int r, int c, int num_rows, int num_cols, int mB)
{
int mA_rows = rc_matrix[mA].r;
int mA_cols = rc_matrix[mA].c;
@@ -1241,7 +1235,7 @@ void ClipMatrix(int mA, int r, int c, int num_rows, int num_cols, int mB)
if(mB_rows < 0)
{
DimMatrix(mB, mA_rows, mA_cols, false);
ClearMatrix(mB);
rc_clearMatrix(mB);
return;
}
@@ -1251,7 +1245,7 @@ void ClipMatrix(int mA, int r, int c, int num_rows, int num_cols, int mB)
if(mB_cols < 0)
{
DimMatrix(mB, mA_rows, mA_cols, false);
ClearMatrix(mB);
rc_clearMatrix(mB);
return;
}
@@ -1259,7 +1253,7 @@ void ClipMatrix(int mA, int r, int c, int num_rows, int num_cols, int mB)
for(int row = r; row < (r+num_rows); row++)
for(int col = c; col < (c+num_cols); col++)
SetMatrixValue( mB, row-r, col-c, MatrixValue(mA, row, col));
rc_setMatrixValue( mB, row-r, col-c, rc_matrixValue(mA, row, col));
}
int rc_convertFromIrrMatrix(irr::core::matrix4 irr_mat, int mB = -1)
@@ -1279,15 +1273,15 @@ int rc_convertFromIrrMatrix(irr::core::matrix4 irr_mat, int mB = -1)
rc_matrix[mA].data[i*4+3] = irr_mat[i*4+3];
}
TransposeMatrix(mA, mB);
DeleteMatrix(mA);
rc_transposeMatrix(mA, mB);
rc_deleteMatrix(mA);
return mB;
}
irr::core::matrix4 rc_convertToIrrMatrix(int mA)
{
int mB = DimMatrix(NEW_MATRIX, 4, 4);
TransposeMatrix(mA, mB);
rc_transposeMatrix(mA, mB);
irr::core::matrix4 irr_mat;
@@ -1299,7 +1293,7 @@ irr::core::matrix4 rc_convertToIrrMatrix(int mA)
irr_mat[i*4+3] = rc_matrix[mB].data[i*4+3];
}
DeleteMatrix(mB);
rc_deleteMatrix(mB);
return irr_mat;
}

424
rcbasic_runtime/rc_net.h Normal file
View File

@@ -0,0 +1,424 @@
#ifndef RC_NET_H_INCLUDED
#define RC_NET_H_INCLUDED
#include "rc_os_defines.h"
#ifdef RC_ANDROID
#define RC_MOBILE
#endif
#ifdef RC_IOS
#define RC_MOBILE
#endif
#ifdef RC_ANDROID
#include <android/log.h>
//Using SDL and standard IO
#include "SDL.h"
#include <string>
#include <sstream>
#include <stdio.h>
#include <iostream>
#include "SDL_net.h"
#include <assert.h>
#include <vector>
#else
#ifdef RC_IOS
//Using SDL and standard IO
#include "SDL2/SDL.h"
#include <string>
#include <sstream>
#include <stdio.h>
#include <iostream>
#include <vector>
#include "SDL2/SDL_net.h"
#else
//Using SDL and standard IO
#include <SDL2/SDL.h>
#include <string>
#include <sstream>
#include <stdio.h>
#include <iostream>
#include <vector>
#include <SDL2/SDL_net.h>
#include <unistd.h>
#include <assert.h>
#endif //RC_IOS
#endif // RC_ANDROID
const int MAX_SOCKETS = 256;
struct rc_tcp_socket_obj
{
TCPsocket socket;
bool active = false;
};
std::vector<rc_tcp_socket_obj> rc_tcp_socket;
struct rc_udp_socket_obj
{
UDPsocket socket;
bool active = false;
};
std::vector<rc_udp_socket_obj> rc_udp_socket;
UDPpacket * rc_udp_packet;
int rc_udp_channel;
std::string rc_udp_data;
int rc_udp_len;
int rc_udp_maxlen;
std::string rc_udp_host;
Uint16 rc_udp_port;
int rc_packet_size = 0;
SDLNet_SocketSet rc_socket_set;
bool rc_net_init()
{
if (SDLNet_Init() < 0)
{
fprintf(stderr, "SDLNet_Init: %s\n", SDLNet_GetError());
//exit(EXIT_FAILURE);
return false;
}
rc_socket_set = SDLNet_AllocSocketSet(MAX_SOCKETS*2);
rc_udp_packet = SDLNet_AllocPacket(512);
rc_packet_size = 512;
return true;
}
bool rc_net_quit()
{
SDLNet_Quit();
}
int rc_net_tcp_openSocket(std::string host, Uint16 port)
{
int id = -1;
for(int i = 0; i < rc_tcp_socket.size(); i++)
{
if(!rc_tcp_socket[i].active)
{
id = i;
break;
}
}
if(id < 0)
{
rc_tcp_socket_obj obj;
rc_tcp_socket.push_back(obj);
}
IPaddress ip;
if(host.compare("") == 0)
{
//exit(0);
SDLNet_ResolveHost(&ip, NULL, port);
}
else
{
//exit(0);
SDLNet_ResolveHost(&ip, host.c_str(), port);
}
rc_tcp_socket[id].socket = SDLNet_TCP_Open(&ip);
if(!rc_tcp_socket[id].socket)
return -1;
//cout << "Add socket to socket_set" << endl;
SDLNet_TCP_AddSocket(rc_socket_set, rc_tcp_socket[id].socket);
return id;
}
void rc_net_tcp_closeSocket(int _socket)
{
if(rc_tcp_socket[_socket].socket == NULL)
{
rc_tcp_socket[_socket].active = false;
return;
}
SDLNet_TCP_DelSocket(rc_socket_set, rc_tcp_socket[_socket].socket);
SDLNet_TCP_Close(rc_tcp_socket[_socket].socket);
rc_tcp_socket[_socket].socket = NULL;
rc_tcp_socket[_socket].active = false;
}
Uint32 rc_net_tcp_remoteHost(int _socket)
{
IPaddress * ip = SDLNet_TCP_GetPeerAddress(rc_tcp_socket[_socket].socket);
return ip->host;
}
Uint32 rc_net_tcp_remotePort(int _socket)
{
IPaddress * ip = SDLNet_TCP_GetPeerAddress(rc_tcp_socket[_socket].socket);
return ip->port;
}
int rc_net_checkSockets(Uint32 m)
{
return SDLNet_CheckSockets(rc_socket_set, m);
}
int rc_net_tcp_socketReady(int _socket)
{
return SDLNet_SocketReady(rc_tcp_socket[_socket].socket);
}
int rc_net_tcp_getData(int socket, int numBytes, void * dst)
{
int rtn = SDLNet_TCP_Recv(rc_tcp_socket[socket].socket, dst, numBytes);
return rtn;
}
int rc_net_tcp_getData_str(int socket, int numBytes, std::string * dst)
{
char c[numBytes+1];
int rtn = rc_net_tcp_getData(socket, numBytes, c);
c[numBytes] = '\0';
//cout << "Read bytes: " << (string)c << endl;
dst[0] = c;
return rtn;
}
int rc_net_tcp_getData_dbl(int socket, int numBytes, double * dst)
{
int i[numBytes];
int rtn = rc_net_tcp_getData(socket, numBytes, i);
for(int n = 0; n < numBytes; n++)
{
dst[n] = i[n];
}
return rtn;
}
void rc_net_tcp_sendData(int socket, std::string data)
{
SDLNet_TCP_Send(rc_tcp_socket[socket].socket, data.c_str(), data.length());
}
bool rc_net_tcp_acceptSocket(int socket_server, int socket_client)
{
//cout << "\n\nthis is a test\n\n";
if(rc_tcp_socket[socket_server].socket == NULL)
{
//cout << "no server" << endl;
return false;
}
bool val = (rc_tcp_socket[socket_client].socket = SDLNet_TCP_Accept(rc_tcp_socket[socket_server].socket));
if(val)
SDLNet_TCP_AddSocket(rc_socket_set, rc_tcp_socket[socket_client].socket);
//cout << "cp1\n";
return val;
}
bool rc_net_udp_openSocket(Uint16 port)
{
int socket = -1;
for(int i = 0; i < rc_udp_socket.size(); i++)
{
if(!rc_udp_socket[i].active)
{
socket = i;
break;
}
}
if(socket < 0)
{
rc_udp_socket_obj obj;
socket = rc_udp_socket.size();
rc_udp_socket.push_back(obj);
}
bool rtn = (bool)(rc_udp_socket[socket].socket = SDLNet_UDP_Open(port));
if(rtn)
{
SDLNet_UDP_AddSocket(rc_socket_set, rc_udp_socket[socket].socket);
rc_udp_socket[socket].active = true;
}
else
{
rc_udp_socket[socket].active = false;
rc_udp_socket[socket].socket = NULL;
return -1;
}
return socket;
}
int rc_net_udp_socketReady(int socket)
{
return SDLNet_SocketReady(rc_udp_socket[socket].socket);
}
int rc_net_udp_readStream(int socket, std::string * host, double * port, std::string * dst)
{
//cout << "DEBUG READSTREAM\n";
//UDPsocket sd; /* Socket descriptor */
//UDPpacket *p; /* Pointer to packet memory */
//int quit = 0;
/* Make space for the packet */
//if (!(rc_udp_packet = SDLNet_AllocPacket(512)))
//{
// fprintf(stderr, "SDLNet_AllocPacket: %s\n", SDLNet_GetError());
// exit(EXIT_FAILURE);
//}
/* Main loop */
/* Wait a packet. UDP_Recv returns != 0 if a packet is coming */
//while(!quit)
//{
if (SDLNet_UDP_Recv(rc_udp_socket[socket].socket, rc_udp_packet))
{
//printf("UDP Packet incoming\n");
//printf("\tChan: %d\n", rc_udp_packet->channel);
rc_udp_channel = rc_udp_packet->channel;
//printf("\tData: %s\n", (char *)rc_udp_packet->data);
const char * c = (const char *)rc_udp_packet->data;
//rc_udp_data = (string)c;
*dst = (std::string)c;
//printf("\tLen: %d\n", rc_udp_packet->len);
rc_udp_len = rc_udp_packet->len;
//printf("\tMaxlen: %d\n", rc_udp_packet->maxlen);
rc_udp_maxlen = rc_udp_packet->maxlen;
//printf("\tStatus: %d\n", rc_udp_packet->status);
//printf("\tAddress: %x %x\n", rc_udp_packet->address.host, rc_udp_packet->address.port);
//rc_udp_host = SDLNet_ResolveIP(&rc_udp_packet->address);
*host = SDLNet_ResolveIP(&rc_udp_packet->address);
//rc_udp_port = rc_udp_packet->address.port;
*port = rc_udp_packet->address.port;
return 1;
//quit = 1;
}
else
{
rc_udp_channel = 0;
//rc_udp_data = "";
*dst = "";
rc_udp_len = 0;
rc_udp_maxlen = rc_udp_packet->maxlen;
//rc_udp_host = SDLNet_ResolveIP(&rc_udp_packet->address);
*host = SDLNet_ResolveIP(&rc_udp_packet->address);
//rc_udp_port = rc_udp_packet->address.port;
*port = rc_udp_packet->address.port;
return 0;
}
//}
//SDLNet_FreePacket(rc_udp_packet);
}
Uint32 rc_net_udp_len()
{
return rc_udp_len;
}
Uint32 rc_net_udp_maxlen()
{
return rc_udp_maxlen;
}
std::string rc_net_udp_getRemoteHost(int socket)
{
IPaddress * ip = SDLNet_UDP_GetPeerAddress(rc_udp_socket[socket].socket,0);
//
return SDLNet_ResolveIP(ip);
}
Uint32 rc_net_udp_getRemotePort(int socket)
{
IPaddress * ip = SDLNet_UDP_GetPeerAddress(rc_udp_socket[socket].socket,0);
return ip->port;
}
void rc_net_udp_closeSocket(int socket)
{
SDLNet_UDP_DelSocket(rc_socket_set, rc_udp_socket[socket].socket);
SDLNet_UDP_Close(rc_udp_socket[socket].socket);
rc_udp_socket[socket].socket = NULL;
rc_udp_socket[socket].active = false;
}
int rc_net_udp_sendData(int slot, std::string host, Uint16 port, std::string s_data)
{
IPaddress srvadd;
if(s_data.length()+1 > rc_packet_size)
{
rc_packet_size = SDLNet_ResizePacket(rc_udp_packet, s_data.length()+1);
if(rc_packet_size < s_data.length())
{
std::cout << "UDP_SendData Error: " << SDLNet_GetError() << endl;
return 0;
}
}
if(rc_udp_packet == NULL)
return 0;
if (SDLNet_ResolveHost(&srvadd, host.c_str(), port) == -1)
{
std::cout << "UDP_SendData Error: " << SDLNet_GetError() << "\n";
//exit(EXIT_FAILURE);
return 0;
}
rc_udp_packet->address.host = srvadd.host;
rc_udp_packet->address.port = srvadd.port;
rc_udp_packet->data = (Uint8*)s_data.c_str();
rc_udp_packet->len = s_data.length()+1;
//cout << "#Data = " << (char*)rc_udp_packet->data << endl;
//cout << "#Length = " << rc_udp_packet->len << endl;
SDLNet_UDP_Send(rc_udp_socket[slot].socket, -1, rc_udp_packet);
return 1;
}
std::string rc_byteToString(Uint8 n)
{
std::stringstream s;
s << (Uint32)n;
return s.str();
}
std::string rc_net_myLocalIP()
{
//cout << "MYLOCALIP" << endl;
IPaddress myIP;
myIP.host = 0;
myIP.port = 0;
std::string net_name = SDLNet_ResolveIP(&myIP);
SDLNet_ResolveHost(&myIP,net_name.c_str(),0);
std::string ip = "";
ip += rc_byteToString((Uint8)myIP.host) + ".";
ip += rc_byteToString((Uint8)(myIP.host >> 8)) + ".";
ip += rc_byteToString((Uint8)(myIP.host >> 16)) + ".";
ip += rc_byteToString((Uint8)(myIP.host >> 24));
//cout << "vagina: " << myIP.host << endl;
return ip;
}
#endif // RC_NET_H_INCLUDED

9
rcbasic_runtime/rc_stdlib.h
View File

@@ -1405,8 +1405,9 @@ inline std::string rc_intern_env(std::string v)
#endif
}
inline int rc_intern_setEnv(std::string name, std::string value, int overwrite)
inline int rc_intern_setEnv(std::string name, std::string value)
{
int overwrite = 1;
#ifdef RC_WINDOWS
//string env_cmd = name + "=" + value;
return SetEnvironmentVariable(name.c_str(), value.c_str()) ? 1 : 0;
@@ -1649,4 +1650,10 @@ std::string rc_intern_android_jni_message(std::string arg_c)
}
#endif
int rc_numCPUs()
{
return SDL_GetCPUCount();
}
#endif // RC_STDLIB_H_INCLUDED

109
rcbasic_runtime/rc_video.h Normal file
View File

@@ -0,0 +1,109 @@
#ifndef RC_VIDEO_H_INCLUDED
#define RC_VIDEO_H_INCLUDED
#include "rc_gfx_core.h"
#include <irrtheora.h>
void rc_loadVideo( std::string vid_file )
{
irrtheora::loadVideo(vid_file);
}
void rc_playVideo( int v_loops )
{
if(rc_active_canvas < 0 || rc_active_canvas >= rc_canvas.size())
{
std::cout << "PlayVideo Error: No Active Canvas available" << std::endl;
return;
}
if(!rc_canvas[rc_active_canvas].texture)
{
std::cout << "PlayVideo Error: No Active Canvas available" << std::endl;
return;
}
irrtheora::playVideo(v_loops, rc_canvas[rc_active_canvas].texture);
}
void rc_pauseVideo( )
{
irrtheora::pauseVideo();
}
void rc_stopVideo( )
{
irrtheora::stopVideo();
}
void rc_setVideoPosition(Uint32 pos)
{
irrtheora::setVideoPosition(pos);
}
void rc_resumeVideo( )
{
irrtheora::resumeVideo();
}
Uint32 rc_getVideoPosition( )
{
return irrtheora::videoPosition();
}
void rc_deleteVideo( )
{
irrtheora::deleteVideo();
}
bool rc_videoIsPlaying( )
{
return irrtheora::videoIsPlaying();
}
bool rc_videoEnd( )
{
return irrtheora::videoEnd();
}
void rc_getVideoStats( std::string vid_file, double* vlen, double* vfps, double* frame_w, double* frame_h )
{
irrtheora::getVideoStats(vid_file, vlen, vfps, frame_w, frame_h);
}
void rc_setVideoDrawRect( double x, double y, double w, double h )
{
irrtheora::setVideoDrawRect(x, y, w, h);
}
void rc_getVideoDrawRect( double* x, double* y, double* w, double* h )
{
irrtheora::getVideoDrawRect(x, y, w, h);
}
void rc_getVideoSize( double* w, double* h )
{
irrtheora::getVideoSize(w, h);
}
bool rc_videoExists( )
{
return irrtheora::videoExists();
}
void rc_setVideoVolume( int vol )
{
irrtheora::setVideoVolume(vol);
}
int rc_getVideoVolume( )
{
return irrtheora::getVideoVolume();
}
#endif // RC_VIDEO_H_INCLUDED