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

Added post processing effects and custom render process functions

Browse Source
This commit is contained in:
n00b87
2025-11-10 23:22:10 -06:00
parent e5deb6bc86
commit 5bedafc8c8
18 changed files with 3225 additions and 1007 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
rcbasic_runtime/main.cpp
View File

@@ -57,6 +57,7 @@
#include "rc_video.h"
#include "rc_steam_lib.h"
#include "rc_windowclose.h"
#include "rc_render_control.h"
#include "rc_test.h"
#include <irrtheora.h>
@@ -4398,7 +4399,7 @@ int main(int argc, char * argv[])
if(rc_filename.compare("--version")==0)
{
cout << "RCBASIC Runtime v4.6" << endl;
cout << "RCBASIC Runtime v4.7" << endl;
return 0;
}

1795
rcbasic_runtime/rc_defines.h
View File

File diff suppressed because it is too large Load Diff

45
rcbasic_runtime/rc_func130_cases.h
View File

@@ -649,6 +649,27 @@ case FN_SetSpriteCanvasRenderPriority: //Number Function
case FN_GetSpriteCanvasRenderPriority: //Sub Procedure
rc_getSpriteCanvasRenderPriority( GETSPRITECANVASRENDERPRIORITY_C_NUM, &GETSPRITECANVASRENDERPRIORITY_PRIORITY, &GETSPRITECANVASRENDERPRIORITY_ORDER );
break;
case FN_AddPostEffect: //Number Function
rc_push_num(rc_addPostEffect( ADDPOSTEFFECT_C_NUM, ADDPOSTEFFECT_EFFECT_TYPE ));
break;
case FN_RemovePostEffect: //Sub Procedure
rc_removePostEffect( REMOVEPOSTEFFECT_C_NUM, REMOVEPOSTEFFECT_EFFECT_NUM );
break;
case FN_SetPostEffectProperty: //Sub Procedure
rc_setPostEffectProperty( SETPOSTEFFECTPROPERTY_C_NUM, SETPOSTEFFECTPROPERTY_EFFECT_NUM, SETPOSTEFFECTPROPERTY_PROPERTY, SETPOSTEFFECTPROPERTY_PROPERTY_VALUE );
break;
case FN_GetPostEffectProperty: //Number Function
rc_push_num(rc_getPostEffectProperty( GETPOSTEFFECTPROPERTY_C_NUM, GETPOSTEFFECTPROPERTY_EFFECT_NUM, GETPOSTEFFECTPROPERTY_PROPERTY ));
break;
case FN_ClearPostEffects: //Sub Procedure
rc_clearPostEffects( CLEARPOSTEFFECTS_C_NUM );
break;
case FN_SetPostEffectActive: //Sub Procedure
rc_setPostEffectActive( SETPOSTEFFECTACTIVE_C_NUM, SETPOSTEFFECTACTIVE_EFFECT_NUM, SETPOSTEFFECTACTIVE_FLAG );
break;
case FN_PostEffectIsActive: //Number Function
rc_push_num(rc_postEffectIsActive( POSTEFFECTISACTIVE_C_NUM, POSTEFFECTISACTIVE_EFFECT_NUM ));
break;
case FN_Circle: //Sub Procedure
rc_drawCircle( CIRCLE_X, CIRCLE_Y, CIRCLE_RADIUS );
break;
@@ -2105,6 +2126,21 @@ case FN_GetMeshPolygonCount: //Number Function
case FN_FlipMeshSurfaces: //Sub Procedure
rc_flipMeshSurfaces( FLIPMESHSURFACES_MESH );
break;
case FN_SetMeshBuffer: //Number Function
rc_push_num(rc_setMeshBuffer( SETMESHBUFFER_MESH_ID, SETMESHBUFFER_BUFFER_NUM, SETMESHBUFFER_VERTEX_COUNT, &SETMESHBUFFER_VERTEX_DATA, &SETMESHBUFFER_NORMAL_DATA, &SETMESHBUFFER_UV_DATA, SETMESHBUFFER_INDEX_COUNT, &SETMESHBUFFER_INDEX_DATA ));
break;
case FN_GetMeshBufferCount: //Number Function
rc_push_num(rc_getMeshBufferCount( GETMESHBUFFERCOUNT_MESH_ID ));
break;
case FN_GetMeshBufferVertexCount: //Number Function
rc_push_num(rc_getMeshBufferVertexCount( GETMESHBUFFERVERTEXCOUNT_MESH_ID, GETMESHBUFFERVERTEXCOUNT_BUFFER_INDEX ));
break;
case FN_GetMeshBufferIndexCount: //Number Function
rc_push_num(rc_getMeshBufferIndexCount( GETMESHBUFFERINDEXCOUNT_MESH_ID, GETMESHBUFFERINDEXCOUNT_BUFFER_INDEX ));
break;
case FN_GetMeshBuffer: //Number Function
rc_push_num(rc_getMeshBuffer( GETMESHBUFFER_MESH_ID, GETMESHBUFFER_BUFFER_INDEX, &GETMESHBUFFER_VERTEX_DATA, &GETMESHBUFFER_NORMAL_DATA, &GETMESHBUFFER_UV_DATA, &GETMESHBUFFER_INDEX_DATA ));
break;
case FN_CreateAnimatedActor: //Number Function
rc_push_num(rc_createAnimatedActor( CREATEANIMATEDACTOR_MESH ));
break;
@@ -2846,6 +2882,15 @@ case FN_SetSceneAmbientColor: //Sub Procedure
case FN_GetSceneAmbientColor: //Number Function
rc_push_num(rc_getSceneAmbientColor( ));
break;
case FN_Pipeline_Begin: //Sub Procedure
rc_pipeline_Begin( );
break;
case FN_Pipeline_End: //Sub Procedure
rc_pipeline_End( );
break;
case FN_Pipeline_Render: //Sub Procedure
rc_pipeline_Render( );
break;
case FN_startParticleEmitter: //Sub Procedure
rc_startParticleEmitter( STARTPARTICLEEMITTER_ACTOR );
break;

9
rcbasic_runtime/rc_gfx.h
View File

@@ -29,6 +29,7 @@
#include "rc_spritelib.h"
#include "rc_tilelib.h"
#include "rc_joints.h"
#include "rc_post_fx.h"
#include <irrtheora.h>
@@ -1245,6 +1246,14 @@ void rc_canvasClose(int canvas_id)
rc_canvas[canvas_id].sprite_id.clear();
//delete post effects for canvas
for(int i = 0; i < rc_canvas[canvas_id].post_effect.size(); i++)
{
rc_removePostEffect(canvas_id, i);
}
rc_canvas[canvas_id].post_effect.clear();
if(rc_active_canvas == canvas_id)
rc_active_canvas = -1;

25
rcbasic_runtime/rc_gfx_core.h
View File

@@ -334,6 +334,28 @@ struct rc_spriteCanvasProperties
int order;
};
#define RC_POST_PROCESS_BLOOM 1
#define RC_POST_PROCESS_BLUR 2
#define RC_POST_PROCESS_MOTION_BLUR 3
#define RC_POST_PROCESS_RADIAL_BLUR 4
#define RC_POST_PROCESS_COLORIZE 5
#define RC_POST_PROCESS_INVERT 6
#define RC_POST_PROCESS_DISTORTION 7
// strength, distance, multiplier, saturation, color
#define RC_PP_PROPERTY_STRENGTH 1
#define RC_PP_PROPERTY_DISTANCE 2
#define RC_PP_PROPERTY_MULTIPLIER 3
#define RC_PP_PROPERTY_SATURATION 4
#define RC_PP_PROPERTY_COLOR 5
struct rc_post_effect
{
int type;
void* object;
bool is_active;
};
#define RC_CANVAS_TYPE_2D 0
#define RC_CANVAS_TYPE_3D 1
#define RC_CANVAS_TYPE_SPRITE 2
@@ -382,12 +404,15 @@ struct rc_canvas_obj
rc_physicsWorld2D_obj physics2D;
irr::core::array<irr::s32> sprite_id;
rc_spriteCanvasProperties spriteCanvasProperties;
irr::core::array<rc_post_effect> post_effect;
};
irr::core::array<rc_canvas_obj> rc_canvas;
irr::core::array<u32> rc_canvas_zOrder;
int rc_active_canvas = -1;
bool hasPreUpdated = false;
bool manual_render_control = false;
irr::video::SColor rc_active_color(0,0,0,0);
irr::video::SColor rc_clear_color(0,0,0,0);

159
rcbasic_runtime/rc_mesh.h
View File

@@ -398,7 +398,7 @@ int rc_createVolumeLightMesh( double u, double v, double foot_color, double tail
//create mesh from geometry data [TODO]
bool rc_addMeshBuffer(int mesh_id, int vertex_count, double* vertex_data, double* normal_data, double* uv_data, int index_count, double* index_data)
int rc_addMeshBuffer(int mesh_id, int vertex_count, double* vertex_data, double* normal_data, double* uv_data, int index_count, double* index_data)
{
irr::scene::ISkinnedMesh * mesh = (irr::scene::ISkinnedMesh*) rc_mesh[mesh_id].mesh;
@@ -407,7 +407,7 @@ bool rc_addMeshBuffer(int mesh_id, int vertex_count, double* vertex_data, double
if(!mbuf)
{
mesh->drop();
return false;
return -1;
}
irr::core::array<irr::video::S3DVertex> vertices;
@@ -437,7 +437,162 @@ bool rc_addMeshBuffer(int mesh_id, int vertex_count, double* vertex_data, double
}
int mbuf_index = mesh->getMeshBufferCount()-1;
return mbuf_index;
}
bool rc_setMeshBuffer(int mesh_id, int buffer_index, int vertex_count, double* vertex_data, double* normal_data, double* uv_data, int index_count, double* index_data)
{
irr::scene::ISkinnedMesh * mesh = (irr::scene::ISkinnedMesh*) rc_mesh[mesh_id].mesh;
if(buffer_index < 0 || buffer_index >= mesh->getMeshBufferCount())
return false;
irr::scene::SSkinMeshBuffer* mbuf = (irr::scene::SSkinMeshBuffer*)mesh->getMeshBuffer(buffer_index);
if(!mbuf)
{
mesh->drop();
return false;
}
irr::core::array<irr::video::S3DVertex> vertices;
irr::core::array<irr::u16> indices;
for(int i = 0; i < vertex_count; i++)
{
irr::video::S3DVertex v;
v.Pos = irr::core::vector3df( (irr::f32) vertex_data[i*3], (irr::f32) vertex_data[i*3+1], (irr::f32) vertex_data[i*3+2] );
v.Normal = irr::core::vector3df( (irr::f32) normal_data[i*3], (irr::f32) normal_data[i*3+1], (irr::f32) normal_data[i*3+2] );
v.TCoords = irr::core::vector2df( (irr::f32) uv_data[i*2], (irr::f32) uv_data[i*2+1] );
vertices.push_back(v);
}
for(int i = 0; i < index_count; i++)
{
indices.push_back( (irr::u16) index_data[i] );
}
if(indices.size() > 0)
{
mbuf->Indices.clear();
mbuf->Vertices_Standard.clear();
for(int i = 0; i < vertices.size(); i++)
mbuf->Vertices_Standard.push_back(vertices[i]);
for(int i = 0; i < indices.size(); i++)
mbuf->Indices.push_back(indices[i]);
}
return true;
}
int rc_getMeshBufferCount(int mesh_id)
{
irr::scene::ISkinnedMesh * mesh = (irr::scene::ISkinnedMesh*) rc_mesh[mesh_id].mesh;
if(mesh_id < 0 || mesh_id >= rc_mesh.size())
return false;
return rc_mesh[mesh_id].mesh->getMeshBufferCount();
}
int rc_getMeshBufferVertexCount(int mesh_id, int buffer_index)
{
irr::scene::ISkinnedMesh * mesh = (irr::scene::ISkinnedMesh*) rc_mesh[mesh_id].mesh;
if(mesh_id < 0 || mesh_id >= rc_mesh.size())
return 0;
int buffer_count = rc_mesh[mesh_id].mesh->getMeshBufferCount();
if(buffer_index < 0 || buffer_index >= buffer_count)
return 0;
irr::scene::SSkinMeshBuffer* mbuf = (irr::scene::SSkinMeshBuffer*)mesh->getMeshBuffer(buffer_index);
if(!mbuf)
{
return 0;
}
return mbuf->getVertexCount();
}
int rc_getMeshBufferIndexCount(int mesh_id, int buffer_index)
{
irr::scene::ISkinnedMesh * mesh = (irr::scene::ISkinnedMesh*) rc_mesh[mesh_id].mesh;
if(mesh_id < 0 || mesh_id >= rc_mesh.size())
return 0;
int buffer_count = rc_mesh[mesh_id].mesh->getMeshBufferCount();
if(buffer_index < 0 || buffer_index >= buffer_count)
return 0;
irr::scene::SSkinMeshBuffer* mbuf = (irr::scene::SSkinMeshBuffer*)mesh->getMeshBuffer(buffer_index);
if(!mbuf)
{
return 0;
}
return mbuf->getIndexCount();
}
bool rc_getMeshBuffer(int mesh_id, int buffer_index, double* vertex_data, double* normal_data, double* uv_data, double* index_data)
{
irr::scene::ISkinnedMesh * mesh = (irr::scene::ISkinnedMesh*) rc_mesh[mesh_id].mesh;
if(mesh_id < 0 || mesh_id >= rc_mesh.size())
return false;
int buffer_count = rc_mesh[mesh_id].mesh->getMeshBufferCount();
if(buffer_index < 0 || buffer_index >= buffer_count)
return false;
irr::scene::SSkinMeshBuffer* mbuf = (irr::scene::SSkinMeshBuffer*)mesh->getMeshBuffer(buffer_index);
if(!mbuf)
{
return false;
}
int vertex_count = mbuf->getVertexCount();
int index_count = mbuf->getIndexCount();
for(int i = 0; i < vertex_count; i++)
{
irr::video::S3DVertex* v = mbuf->getVertex(i);
vertex_data[i*3] = (double)v->Pos.X;
vertex_data[i*3+1] = (double)v->Pos.Y;
vertex_data[i*3+2] = (double)v->Pos.Z;
normal_data[i*3] = (double)v->Normal.X;
normal_data[i*3+1] = (double)v->Normal.Y;
normal_data[i*3+2] = (double)v->Normal.Z;
uv_data[i*2] = (double)v->TCoords.X;
uv_data[i*2+1] = (double)v->TCoords.Y;
}
for(int i = 0; i < index_count; i++)
{
index_data[i] = (double)mbuf->getIndices()[i];
}
return true;
}
#endif // RC_MESH_H_INCLUDED

2
rcbasic_runtime/rc_net.h
View File

@@ -455,7 +455,7 @@ void rc_net_udp_closeSocket(int socket)
int rc_net_udp_sendData(int slot, std::string host, Uint16 port, std::string s_data)
{
if(socket < 0 || socket >= rc_udp_socket.size())
if(slot < 0 || slot >= rc_udp_socket.size())
return 0;
IPaddress srvadd;

1588
rcbasic_runtime/rc_post_fx.h Normal file
View File

File diff suppressed because it is too large Load Diff

212
rcbasic_runtime/rc_render_control.h Normal file
View File

@@ -0,0 +1,212 @@
#ifndef RC_RENDER_CONTROL_H_INCLUDED
#define RC_RENDER_CONTROL_H_INCLUDED
#include <irrlicht.h>
#include "rc_gfx_core.h"
#include "rc_post_fx.h"
void rc_pipeline_Begin()
{
manual_render_control = true;
VideoDriver->beginScene(true, true);
Uint32 current_time_ms = SDL_GetTicks();
double frame_current_time = ((double)current_time_ms)/1000.0;
for(int i = 0; i < rc_transition_actor.size();)
{
int t_actor = rc_transition_actor[i];
if((frame_current_time - rc_actor[t_actor].transition_start_time) >= rc_actor[t_actor].transition_time)
{
irr::scene::IAnimatedMeshSceneNode* node = (irr::scene::IAnimatedMeshSceneNode*)rc_actor[t_actor].mesh_node;
node->setTransitionTime(0);
node->setJointMode(irr::scene::EJUOR_NONE);
rc_actor[t_actor].transition = false;
rc_actor[t_actor].transition_time = 0;
rc_actor[t_actor].transition_start_time = 0;
rc_transition_actor.erase(t_actor);
rc_actor[t_actor].animation[0].start_frame = (int)rc_actor[t_actor].transition_frame;
rc_actor[t_actor].animation[0].end_frame = (int)rc_actor[t_actor].transition_frame;
rc_actor[t_actor].animation[0].fps = 0;
rc_actor[t_actor].current_animation_loop = 0;
rc_actor[t_actor].isPlaying = true;
rc_actor[t_actor].current_animation = 0;
}
else
{
//std::cout << "Animate dammit" << std::endl;
irr::scene::IAnimatedMeshSceneNode* node = (irr::scene::IAnimatedMeshSceneNode*)rc_actor[t_actor].mesh_node;
node->animateJoints();
i++;
}
}
}
void rc_pipeline_End()
{
int win_w = 0, win_h = 0;
double w_scale = 1, h_scale = 1;
if(rc_window)
{
SDL_GetWindowSize(rc_window, &win_w, &win_h);
}
if(manual_render_control)
{
#ifdef RC_DRIVER_GLES2
w_scale = ( (double)win_w / (double)rc_window_size.Width );
h_scale = ( (double)win_h / (double)rc_window_size.Height );
irr::core::rect<s32> src( irr::core::vector2d<s32>(0,0), rc_canvas[0].texture->getSize() );
irr::core::rect<s32> dest( irr::core::vector2d<s32>(0,0), irr::core::dimension2d<s32>(win_w*w_scale, win_h*h_scale) );
#else
irr::core::rect<s32> src( irr::core::vector2d<s32>(0,0), rc_window_size );
irr::core::rect<s32> dest;
if(rc_windowIsFullscreen())
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(0,0), irr::core::dimension2d<s32>(win_w, win_h) );
else
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(0,rc_canvas[0].texture->getSize().Height - rc_window_size.Height), irr::core::dimension2d<s32>(win_w, win_h) );
#endif // RC_DRIVER_GLES2
VideoDriver->draw2DImage(rc_canvas[0].texture, dest, src);
VideoDriver->endScene();
rc_setActiveCanvas(rc_active_canvas);
#ifdef RC_WEB
emscripten_sleep(0);
#else
SDL_Delay(0);
#endif // RC_WEB
}
manual_render_control = false;
}
void rc_pipeline_Render()
{
if(!manual_render_control)
return;
if(rc_active_canvas < 0 || rc_active_canvas >= rc_canvas.size())
return;
if(rc_canvas[rc_active_canvas].texture)
return;
//VideoDriver->setRenderTarget(rc_canvas[0].texture);
irr::core::vector2d<s32> bb_position(0,0);
irr::core::dimension2d<u32> bb_dimension = rc_canvas[0].texture->getSize();
VideoDriver->setViewPort( irr::core::rect<irr::s32>(bb_position, bb_dimension) );
if(rc_canvas[rc_active_canvas].show3D)
{
//VideoDriver->setRenderTarget(rc_canvas[rc_active_canvas].texture, true, true, irr::video::SColor(255,120,120,120));
if(rc_canvas[rc_active_canvas].camera.camera)
SceneManager->setActiveCamera(rc_canvas[rc_active_canvas].camera.camera);
rc_canvas[rc_active_canvas].camera.update();
VideoDriver->setViewPort(irr::core::rect<irr::s32>(0,0,rc_canvas[rc_active_canvas].texture->getSize().Width,rc_canvas[rc_active_canvas].texture->getSize().Height));
irr::video::SColor current_color = rc_active_color;
irr::video::SMaterial m;
m.Lighting=false;
VideoDriver->setMaterial(m);
VideoDriver->setTransform(video::ETS_WORLD, core::matrix4());
for(int i = 0; i < rc_prim3d_operation.size(); i++)
{
switch(rc_prim3d_operation[i].prim_type)
{
case PRIM3D_LINE:
rc_active_color = rc_prim3d_operation[i].color;
prim3d_drawLine3D(rc_prim3d_operation[i].x[0], rc_prim3d_operation[i].y[0], rc_prim3d_operation[i].z[0],
rc_prim3d_operation[i].x[1], rc_prim3d_operation[i].y[1], rc_prim3d_operation[i].z[1]);
break;
case PRIM3D_BOX:
rc_active_color = rc_prim3d_operation[i].color;
prim3d_drawBox3D(rc_prim3d_operation[i].x[0], rc_prim3d_operation[i].y[0], rc_prim3d_operation[i].z[0],
rc_prim3d_operation[i].x[1], rc_prim3d_operation[i].y[1], rc_prim3d_operation[i].z[1]);
break;
case PRIM3D_TRIANGLE:
rc_active_color = rc_prim3d_operation[i].color;
prim3d_drawTriangle3D(rc_prim3d_operation[i].x[0], rc_prim3d_operation[i].y[0], rc_prim3d_operation[i].z[0],
rc_prim3d_operation[i].x[1], rc_prim3d_operation[i].y[1], rc_prim3d_operation[i].z[1],
rc_prim3d_operation[i].x[2], rc_prim3d_operation[i].y[2], rc_prim3d_operation[i].z[2]);
break;
}
}
rc_active_color = current_color;
rc_setDriverMaterial();
SceneManager->drawAll();
//render post effects
for(int effect_num = 0; effect_num < rc_canvas[rc_active_canvas].post_effect.size(); effect_num++)
{
rc_renderPostEffect(rc_active_canvas, effect_num); //It won't render if not active so no check needs to be done here
}
}
int canvas_id = rc_active_canvas;
if(rc_canvas[canvas_id].texture && rc_canvas[canvas_id].visible)
{
irr::core::rect<s32> dest(rc_canvas[canvas_id].viewport.position, rc_canvas[canvas_id].viewport.dimension);
irr::core::rect<s32> src(rc_canvas[canvas_id].offset, rc_canvas[canvas_id].viewport.dimension);
irr::video::SColor color(rc_canvas[canvas_id].color_mod);
#if defined(RC_DRIVER_GLES2)
if(rc_canvas[canvas_id].type == RC_CANVAS_TYPE_3D)
{
src = irr::core::rect<s32>( irr::core::vector2d<s32>(0, 0), rc_canvas[canvas_id].texture->getSize() );
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(dest.UpperLeftCorner.X, dest.UpperLeftCorner.Y + dest.getHeight()), irr::core::dimension2d<s32>(dest.getWidth(), -1*dest.getHeight()) );
}
else if(rc_canvas[canvas_id].type == RC_CANVAS_TYPE_2D)
{
irr::core::dimension2d<irr::u32> cv_dim = rc_canvas[canvas_id].viewport.dimension;
irr::core::position2d<irr::s32> cv_pos = rc_canvas[canvas_id].viewport.position;
irr::core::vector2d<irr::s32> cv_offset(rc_canvas[canvas_id].offset.X, rc_canvas[canvas_id].texture->getSize().Height - rc_canvas[canvas_id].offset.Y - cv_dim.Height);
src = irr::core::rect<s32>( cv_offset, cv_dim );
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(cv_pos.X, cv_pos.Y + cv_dim.Height), irr::core::dimension2d<s32>(cv_dim.Width, -1*cv_dim.Height) );
}
else if(rc_canvas[canvas_id].type == RC_CANVAS_TYPE_SPRITE)
{
src = irr::core::rect<s32>( irr::core::vector2d<s32>(0, 0), rc_canvas[canvas_id].texture->getSize() );
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(dest.UpperLeftCorner.X, dest.UpperLeftCorner.Y + dest.getHeight()), irr::core::dimension2d<s32>(dest.getWidth(), -1*dest.getHeight()) );
drawSprites(canvas_id);
}
#else
if(rc_canvas[canvas_id].type == RC_CANVAS_TYPE_SPRITE)
{
src = irr::core::rect<s32>( irr::core::vector2d<s32>(0, 0), rc_canvas[canvas_id].viewport.dimension); //sprite layers will just offset the sprites in drawSprites()
drawSprites(canvas_id);
}
#endif // defined
}
}
#endif // RC_RENDER_CONTROL_H_INCLUDED

287
rcbasic_runtime/rc_windowclose.h
View File

@@ -489,38 +489,42 @@ bool rc_update()
Uint32 current_time_ms = SDL_GetTicks();
double frame_current_time = ((double)current_time_ms)/1000.0;
for(int i = 0; i < rc_transition_actor.size();)
{
int t_actor = rc_transition_actor[i];
if(!manual_render_control)
{
for(int i = 0; i < rc_transition_actor.size();)
{
int t_actor = rc_transition_actor[i];
if((frame_current_time - rc_actor[t_actor].transition_start_time) >= rc_actor[t_actor].transition_time)
{
irr::scene::IAnimatedMeshSceneNode* node = (irr::scene::IAnimatedMeshSceneNode*)rc_actor[t_actor].mesh_node;
node->setTransitionTime(0);
node->setJointMode(irr::scene::EJUOR_NONE);
rc_actor[t_actor].transition = false;
rc_actor[t_actor].transition_time = 0;
rc_actor[t_actor].transition_start_time = 0;
rc_transition_actor.erase(t_actor);
if((frame_current_time - rc_actor[t_actor].transition_start_time) >= rc_actor[t_actor].transition_time)
{
irr::scene::IAnimatedMeshSceneNode* node = (irr::scene::IAnimatedMeshSceneNode*)rc_actor[t_actor].mesh_node;
node->setTransitionTime(0);
node->setJointMode(irr::scene::EJUOR_NONE);
rc_actor[t_actor].transition = false;
rc_actor[t_actor].transition_time = 0;
rc_actor[t_actor].transition_start_time = 0;
rc_transition_actor.erase(t_actor);
rc_actor[t_actor].animation[0].start_frame = (int)rc_actor[t_actor].transition_frame;
rc_actor[t_actor].animation[0].end_frame = (int)rc_actor[t_actor].transition_frame;
rc_actor[t_actor].animation[0].fps = 0;
rc_actor[t_actor].current_animation_loop = 0;
rc_actor[t_actor].isPlaying = true;
rc_actor[t_actor].current_animation = 0;
}
else
{
//std::cout << "Animate dammit" << std::endl;
irr::scene::IAnimatedMeshSceneNode* node = (irr::scene::IAnimatedMeshSceneNode*)rc_actor[t_actor].mesh_node;
node->animateJoints();
i++;
}
}
rc_actor[t_actor].animation[0].start_frame = (int)rc_actor[t_actor].transition_frame;
rc_actor[t_actor].animation[0].end_frame = (int)rc_actor[t_actor].transition_frame;
rc_actor[t_actor].animation[0].fps = 0;
rc_actor[t_actor].current_animation_loop = 0;
rc_actor[t_actor].isPlaying = true;
rc_actor[t_actor].current_animation = 0;
}
else
{
//std::cout << "Animate dammit" << std::endl;
irr::scene::IAnimatedMeshSceneNode* node = (irr::scene::IAnimatedMeshSceneNode*)rc_actor[t_actor].mesh_node;
node->animateJoints();
i++;
}
}
}
VideoDriver->beginScene(true, true);
if(!manual_render_control)
VideoDriver->beginScene(true, true);
if(!hasPreUpdated)
{
@@ -532,61 +536,71 @@ bool rc_update()
rc_physics3D.world->stepSimulation(rc_physics3D.DeltaTime*0.001f, rc_physics3D.maxSubSteps, fixed_timestep);
}
for(int canvas_id = 0; canvas_id < rc_canvas.size(); i++)
if(!manual_render_control)
{
if(rc_canvas[canvas_id].show3D)
for(int canvas_id = 0; canvas_id < rc_canvas.size(); canvas_id++)
{
VideoDriver->setRenderTarget(rc_canvas[canvas_id].texture, true, true, irr::video::SColor(255,120,120,120));
if(rc_canvas[canvas_id].show3D)
{
VideoDriver->setRenderTarget(rc_canvas[canvas_id].texture, true, true, rc_clear_color);
if(rc_canvas[canvas_id].camera.camera)
SceneManager->setActiveCamera(rc_canvas[canvas_id].camera.camera);
if(rc_canvas[canvas_id].camera.camera)
SceneManager->setActiveCamera(rc_canvas[canvas_id].camera.camera);
rc_canvas[canvas_id].camera.update();
rc_canvas[canvas_id].camera.update();
VideoDriver->setViewPort(irr::core::rect<irr::s32>(0,0,rc_canvas[canvas_id].texture->getSize().Width,rc_canvas[canvas_id].texture->getSize().Height));
VideoDriver->setViewPort(irr::core::rect<irr::s32>(0,0,rc_canvas[canvas_id].texture->getSize().Width,rc_canvas[canvas_id].texture->getSize().Height));
//irr::core::rect viewport(irr::core::position, rc_canvas[i].viewport.dimension);
//VideoDriver->setViewPort(viewport);
irr::video::SColor current_color = rc_active_color;
irr::video::SMaterial m;
m.Lighting=false;
VideoDriver->setMaterial(m);
VideoDriver->setTransform(video::ETS_WORLD, core::matrix4());
for(int i = 0; i < rc_prim3d_operation.size(); i++)
{
switch(rc_prim3d_operation[i].prim_type)
{
case PRIM3D_LINE:
rc_active_color = rc_prim3d_operation[i].color;
prim3d_drawLine3D(rc_prim3d_operation[i].x[0], rc_prim3d_operation[i].y[0], rc_prim3d_operation[i].z[0],
rc_prim3d_operation[i].x[1], rc_prim3d_operation[i].y[1], rc_prim3d_operation[i].z[1]);
break;
case PRIM3D_BOX:
rc_active_color = rc_prim3d_operation[i].color;
prim3d_drawBox3D(rc_prim3d_operation[i].x[0], rc_prim3d_operation[i].y[0], rc_prim3d_operation[i].z[0],
rc_prim3d_operation[i].x[1], rc_prim3d_operation[i].y[1], rc_prim3d_operation[i].z[1]);
break;
case PRIM3D_TRIANGLE:
rc_active_color = rc_prim3d_operation[i].color;
prim3d_drawTriangle3D(rc_prim3d_operation[i].x[0], rc_prim3d_operation[i].y[0], rc_prim3d_operation[i].z[0],
rc_prim3d_operation[i].x[1], rc_prim3d_operation[i].y[1], rc_prim3d_operation[i].z[1],
rc_prim3d_operation[i].x[2], rc_prim3d_operation[i].y[2], rc_prim3d_operation[i].z[2]);
break;
}
}
rc_active_color = current_color;
rc_setDriverMaterial();
//irr::core::rect viewport(irr::core::position, rc_canvas[i].viewport.dimension);
//VideoDriver->setViewPort(viewport);
irr::video::SColor current_color = rc_active_color;
irr::video::SMaterial m;
m.Lighting=false;
VideoDriver->setMaterial(m);
VideoDriver->setTransform(video::ETS_WORLD, core::matrix4());
for(int i = 0; i < rc_prim3d_operation.size(); i++)
{
switch(rc_prim3d_operation[i].prim_type)
{
case PRIM3D_LINE:
rc_active_color = rc_prim3d_operation[i].color;
prim3d_drawLine3D(rc_prim3d_operation[i].x[0], rc_prim3d_operation[i].y[0], rc_prim3d_operation[i].z[0],
rc_prim3d_operation[i].x[1], rc_prim3d_operation[i].y[1], rc_prim3d_operation[i].z[1]);
break;
case PRIM3D_BOX:
rc_active_color = rc_prim3d_operation[i].color;
prim3d_drawBox3D(rc_prim3d_operation[i].x[0], rc_prim3d_operation[i].y[0], rc_prim3d_operation[i].z[0],
rc_prim3d_operation[i].x[1], rc_prim3d_operation[i].y[1], rc_prim3d_operation[i].z[1]);
break;
case PRIM3D_TRIANGLE:
rc_active_color = rc_prim3d_operation[i].color;
prim3d_drawTriangle3D(rc_prim3d_operation[i].x[0], rc_prim3d_operation[i].y[0], rc_prim3d_operation[i].z[0],
rc_prim3d_operation[i].x[1], rc_prim3d_operation[i].y[1], rc_prim3d_operation[i].z[1],
rc_prim3d_operation[i].x[2], rc_prim3d_operation[i].y[2], rc_prim3d_operation[i].z[2]);
break;
}
}
rc_active_color = current_color;
rc_setDriverMaterial();
SceneManager->drawAll();
//VideoDriver->draw2DRectangle(irr::video::SColor(255,0,255,0), irr::core::rect<irr::s32>(10,40,100,500));
SceneManager->drawAll();
//vector3df p0(0, 0, 0);
//vector3df p1(10, 30, 0);
//vector3df p2(20, -30, 0);
//vector3df p3(30, 0, 0);
//drawBezierCurve(VideoDriver, p0, p1, p2, p3, irr::video::SColor(255, 0, 255, 0), 100);
//render post effects
for(int effect_num = 0; effect_num < rc_canvas[rc_active_canvas].post_effect.size(); effect_num++)
{
rc_renderPostEffect(canvas_id, effect_num); //It won't render if not active so no check needs to be done here
}
VideoDriver->setRenderTarget(rc_canvas[0].texture);
//VideoDriver->draw2DRectangle(irr::video::SColor(255,0,255,0), irr::core::rect<irr::s32>(10,40,100,500));
//vector3df p0(0, 0, 0);
//vector3df p1(10, 30, 0);
//vector3df p2(20, -30, 0);
//vector3df p3(30, 0, 0);
//drawBezierCurve(VideoDriver, p0, p1, p2, p3, irr::video::SColor(255, 0, 255, 0), 100);
VideoDriver->setRenderTarget(rc_canvas[0].texture);
}
}
}
@@ -607,35 +621,41 @@ bool rc_update()
//std::cout << "draw canvas[" << canvas_id << "] (" << rc_canvas[canvas_id].offset.X << ", " << rc_canvas[canvas_id].offset.Y << ") (" << rc_canvas[canvas_id].viewport.dimension.Width << ", " << rc_canvas[canvas_id].viewport.dimension.Height << ")" << std::endl;
#if defined(RC_DRIVER_GLES2)
if(rc_canvas[canvas_id].type == RC_CANVAS_TYPE_3D)
if(!manual_render_control)
{
src = irr::core::rect<s32>( irr::core::vector2d<s32>(0, 0), rc_canvas[canvas_id].texture->getSize() );
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(dest.UpperLeftCorner.X, dest.UpperLeftCorner.Y + dest.getHeight()), irr::core::dimension2d<s32>(dest.getWidth(), -1*dest.getHeight()) );
}
else if(rc_canvas[canvas_id].type == RC_CANVAS_TYPE_2D)
{
irr::core::dimension2d<irr::u32> cv_dim = rc_canvas[canvas_id].viewport.dimension;
irr::core::position2d<irr::s32> cv_pos = rc_canvas[canvas_id].viewport.position;
irr::core::vector2d<irr::s32> cv_offset(rc_canvas[canvas_id].offset.X, rc_canvas[canvas_id].texture->getSize().Height - rc_canvas[canvas_id].offset.Y - cv_dim.Height);
src = irr::core::rect<s32>( cv_offset, cv_dim );
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(cv_pos.X, cv_pos.Y + cv_dim.Height), irr::core::dimension2d<s32>(cv_dim.Width, -1*cv_dim.Height) );
}
else if(rc_canvas[canvas_id].type == RC_CANVAS_TYPE_SPRITE)
{
if(rc_canvas[canvas_id].type == RC_CANVAS_TYPE_3D)
{
src = irr::core::rect<s32>( irr::core::vector2d<s32>(0, 0), rc_canvas[canvas_id].texture->getSize() );
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(dest.UpperLeftCorner.X, dest.UpperLeftCorner.Y + dest.getHeight()), irr::core::dimension2d<s32>(dest.getWidth(), -1*dest.getHeight()) );
}
else if(rc_canvas[canvas_id].type == RC_CANVAS_TYPE_2D)
{
irr::core::dimension2d<irr::u32> cv_dim = rc_canvas[canvas_id].viewport.dimension;
irr::core::position2d<irr::s32> cv_pos = rc_canvas[canvas_id].viewport.position;
irr::core::vector2d<irr::s32> cv_offset(rc_canvas[canvas_id].offset.X, rc_canvas[canvas_id].texture->getSize().Height - rc_canvas[canvas_id].offset.Y - cv_dim.Height);
src = irr::core::rect<s32>( cv_offset, cv_dim );
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(cv_pos.X, cv_pos.Y + cv_dim.Height), irr::core::dimension2d<s32>(cv_dim.Width, -1*cv_dim.Height) );
}
else if(rc_canvas[canvas_id].type == RC_CANVAS_TYPE_SPRITE)
{
src = irr::core::rect<s32>( irr::core::vector2d<s32>(0, 0), rc_canvas[canvas_id].texture->getSize() );
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(dest.UpperLeftCorner.X, dest.UpperLeftCorner.Y + dest.getHeight()), irr::core::dimension2d<s32>(dest.getWidth(), -1*dest.getHeight()) );
drawSprites(canvas_id);
}
src = irr::core::rect<s32>( irr::core::vector2d<s32>(0, 0), rc_canvas[canvas_id].texture->getSize() );
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(dest.UpperLeftCorner.X, dest.UpperLeftCorner.Y + dest.getHeight()), irr::core::dimension2d<s32>(dest.getWidth(), -1*dest.getHeight()) );
drawSprites(canvas_id);
}
}
//dest = irr::core::rect<s32>( irr::core::vector2d<s32>(dest.UpperLeftCorner.X, dest.UpperLeftCorner.Y + dest.getHeight()), irr::core::dimension2d<s32>(dest.getWidth(), -1*dest.getHeight()) );
draw2DImage2(VideoDriver, rc_canvas[canvas_id].texture, src, dest, irr::core::position2d<irr::s32>(0, 0), 0, true, color, screenSize);
#else
if(rc_canvas[canvas_id].type == RC_CANVAS_TYPE_SPRITE)
{
if(!manual_render_control)
{
if(rc_canvas[canvas_id].type == RC_CANVAS_TYPE_SPRITE)
{
src = irr::core::rect<s32>( irr::core::vector2d<s32>(0, 0), rc_canvas[canvas_id].viewport.dimension); //sprite layers will just offset the sprites in drawSprites()
drawSprites(canvas_id);
}
src = irr::core::rect<s32>( irr::core::vector2d<s32>(0, 0), rc_canvas[canvas_id].viewport.dimension); //sprite layers will just offset the sprites in drawSprites()
drawSprites(canvas_id);
}
}
draw2DImage2(VideoDriver, rc_canvas[canvas_id].texture, src, dest, irr::core::position2d<irr::s32>(0, 0), 0, true, color, screenSize);
#endif // defined
@@ -653,49 +673,56 @@ bool rc_update()
//VideoDriver->draw2DRectangle(irr::video::SColor(255,255,0,0), irr::core::rect<irr::s32>(0,0,100,500));
VideoDriver->setRenderTarget(0);
//VideoDriver->beginScene(true, true);
//VideoDriver->draw2DImage(rc_canvas[0].texture, irr::core::vector2d<irr::s32>(0,0));
//debug
//std::cout << "scale:: " << rc_window_size.Width << ", " << win_w << ", " << rc_canvas[0].texture->getSize().Width << std::endl;
//irr::core::rect<s32> src( irr::core::vector2d<s32>(0,0), rc_canvas[0].texture->getSize() );
#ifdef RC_DRIVER_GLES2
irr::core::rect<s32> src( irr::core::vector2d<s32>(0,0), rc_canvas[0].texture->getSize() );
irr::core::rect<s32> dest( irr::core::vector2d<s32>(0,0), irr::core::dimension2d<s32>(win_w*w_scale, win_h*h_scale) );
#else
irr::core::rect<s32> src( irr::core::vector2d<s32>(0,0), rc_window_size );
irr::core::rect<s32> dest;
if(!manual_render_control)
{
//VideoDriver->beginScene(true, true);
//VideoDriver->draw2DImage(rc_canvas[0].texture, irr::core::vector2d<irr::s32>(0,0));
if(rc_windowIsFullscreen())
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(0,0), irr::core::dimension2d<s32>(win_w, win_h) );
else
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(0,rc_canvas[0].texture->getSize().Height - rc_window_size.Height), irr::core::dimension2d<s32>(win_w, win_h) );
#endif // RC_DRIVER_GLES2
//debug
//std::cout << "scale:: " << rc_window_size.Width << ", " << win_w << ", " << rc_canvas[0].texture->getSize().Width << std::endl;
//irr::core::rect<s32> src( irr::core::vector2d<s32>(0,0), rc_canvas[0].texture->getSize() );
#ifdef RC_DRIVER_GLES2
irr::core::rect<s32> src( irr::core::vector2d<s32>(0,0), rc_canvas[0].texture->getSize() );
irr::core::rect<s32> dest( irr::core::vector2d<s32>(0,0), irr::core::dimension2d<s32>(win_w*w_scale, win_h*h_scale) );
#else
irr::core::rect<s32> src( irr::core::vector2d<s32>(0,0), rc_window_size );
irr::core::rect<s32> dest;
//irr::video::SColor color(0);
VideoDriver->draw2DImage(rc_canvas[0].texture, dest, src);
//draw2DImage2(VideoDriver, rc_canvas[0].texture, src, dest, irr::core::position2d<irr::s32>(0, 0), 0, false, color, screenSize);
//irr::core::rect<irr::s32> src( irr::core::vector2d<irr::s32>(0, 0), rc_canvas[0].texture->getSize() );
//irr::core::rect<irr::s32> dest( irr::core::vector2d<irr::s32>(0, 0), irr::core::dimension2d<irr::s32>( );
//draw2DImage2(VideoDriver, rc_canvas[canvas_id].texture, src, dest, irr::core::position2d<irr::s32>(0, 0), 0, true, color, screenSize);
if(rc_windowIsFullscreen())
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(0,0), irr::core::dimension2d<s32>(win_w, win_h) );
else
dest = irr::core::rect<s32>( irr::core::vector2d<s32>(0,rc_canvas[0].texture->getSize().Height - rc_window_size.Height), irr::core::dimension2d<s32>(win_w, win_h) );
#endif // RC_DRIVER_GLES2
//VideoDriver->draw2DImage(rc_image[0].image, irr::core::rect<irr::s32>(0,0,100,100), irr::core::rect<irr::s32>(0,0,100,100));
//VideoDriver->draw2DRectangle(irr::video::SColor(255,255,0,0), irr::core::rect<irr::s32>(0,0,100,100));
//end debug
//irr::video::SColor color(0);
VideoDriver->draw2DImage(rc_canvas[0].texture, dest, src);
//draw2DImage2(VideoDriver, rc_canvas[0].texture, src, dest, irr::core::position2d<irr::s32>(0, 0), 0, false, color, screenSize);
//irr::core::rect<irr::s32> src( irr::core::vector2d<irr::s32>(0, 0), rc_canvas[0].texture->getSize() );
//irr::core::rect<irr::s32> dest( irr::core::vector2d<irr::s32>(0, 0), irr::core::dimension2d<irr::s32>( );
//draw2DImage2(VideoDriver, rc_canvas[canvas_id].texture, src, dest, irr::core::position2d<irr::s32>(0, 0), 0, true, color, screenSize);
//device->getGUIEnvironment()->drawAll();
VideoDriver->endScene();
//VideoDriver->draw2DImage(rc_image[0].image, irr::core::rect<irr::s32>(0,0,100,100), irr::core::rect<irr::s32>(0,0,100,100));
//VideoDriver->draw2DRectangle(irr::video::SColor(255,255,0,0), irr::core::rect<irr::s32>(0,0,100,100));
//end debug
rc_setActiveCanvas(rc_active_canvas);
//device->getGUIEnvironment()->drawAll();
VideoDriver->endScene();
rc_setActiveCanvas(rc_active_canvas);
}
}
hasPreUpdated = false; //Will be set to true if PreUpdate() is called
#ifdef RC_WEB
emscripten_sleep(0);
#else
SDL_Delay(0);
#endif // RC_WEB
if(!manual_render_control)
{
#ifdef RC_WEB
emscripten_sleep(0);
#else
SDL_Delay(0);
#endif // RC_WEB
}
return (!Close);
}