Another post missing is the bit about Triority - which is essentially the GLBasic commands (2D only at the moment) in a Visual Studio/CodeBlocks C++ library. It also has various extras including the basic particles system and the pro-font display routine (which need to be changed).
Another important difference (aside from some command changes) is that it uses SDL2 - if I get 3D working it would then be a mixed of OpenGL and SDL2.
I've included a test program (one using CodeBlocks & MinGW) and the other using Visual Studio 2013 - As I compiled against the 64-bit version of SDL2 libraries, you will need a 64-bit operating system! That only applies for the CodeBlocks version - the VS 2013 only works against the 32-bit libraries, so any OS will work there!
Got some test programs running now - this is around half of the non-3D GLBasic sample programs that I have converted to Triority so far.
Its nothing particularly exciting - its mainly testing the various areas, to make sure they work. So far, none of the extra stuff has been tested (particles, sprite fonts etc).
Some example code :
#include "Triority.h"
int main(int argc, char * argv[])
{
const char *organisation = "organisation";
const char *programName = "programName";
DGInt volume=128.0;
// Initialise Triority
if (__GLB_Defaults(argc, argv, organisation, programName) == false)
{
END();
}
PLAYMUSIC("music.mp3",true);
SLEEP(1000);
while (true)
{
PRINT("Music playing : " + FORMAT_Str(2, 0, ISMUSICPLAYING()), 0, 0);
PRINT("Music volume : " + FORMAT_Str(3, 2, volume), 0, 16);
MUSICVOLUME(volume);
volume -= 0.01;
if (volume <= 0.0)
{
STOPMUSIC();
}
SHOWSCREEN();
}
KEYWAIT();
return true;
}
As you can see, things are kept simple. I will be implementing SETLOOPSUB, which will allow most of the main loop processing to be offloaded to Triority.
Got 30 odd examples up and running here. There are a few that aren't quite correct, but they are easy enough to fix.
It is all preview type at the moment :)
This is the current source file & header. It is working okay - need to redo the PROFONT system, and I'm not too happy about the keyboard reading system, but that can all be looked at later.
MSVCR120.dll fehlt
Good point : You need the VS 2013 redist : http://www.microsoft.com/en-us/download/details.aspx?id=40784
Thanks, now is running.
It should be noted that some programs expect some text/should be displaying text - and you dont see anything. This is mainly because I didn't provide the Default.ttf file - which was a bit naughty. What I need to do is make sure the default font is embedded in the code thereby removing the need for an external file.
Yes, some text examples not go.
Sound and graphics are going well.
I make time a screen video.
Download it straight up, so it can take some time.
In some applications, the AV reported.
Verfällt: 02-Sep-2014
http://snap.ashampoo.com/L97B9LDT (http://snap.ashampoo.com/L97B9LDT)
No idea why Bulldog should complain as it's all virus-free!
Just need to embed a default font into the system and then I'll re-compile everything again.
The BullGuard is no problem, I know the behave of PureBasic.
In general, the AV scanner report something in little exe
or even if with GLBasic the Debuger used.
BullGuard has a Bitdefenderscanner like many other AV.
Bullgard is just a frontend.
I've got a feeling it doesn't like the format of executables created by Visual Studio 2013 - Eset reports no problems.
Here are the updated files, and a video too!
http://youtu.be/qMIdE06KjVs
I've got one more major update to do (with the proportional font sprite system), after which I'll release the initial source code, and hopefully make the basic VS2013 project as well as the Triority project.
The idea is to release the source code
VS2013 Project (and test programs)
VS2003 Project (and test programs)
Codeblocks Project
The main code is now available from my site.
Most GLBasic commands are available, with the exception of FINDPATH and all 3D commands, and all things should work :)
There are a few differences in how some do function though
Quite video of it running in Linux (the sound is out of sync due to recording) : http://www.dailymotion.com/video/x23v9j5_triority-running-in-ubuntu-14_tech
Considering its using software rendering mode (due to the fact that hardware rendering isn't available), the FPS is pretty good!
Let me get this right..
You are programing C programs that use glbasic as a library?
What compiler is that in the new video?
What OS(Windows?)?
I don't think Mr T is using GLB as a library, more of making his own system based on GLB commands I believe.
Lee
Indeed - it uses some of Gernot's code - but only for arrays. In addition, I have added a few memory checks to the code, just in case... Everything else is written by me, but keeping the GLBASIC command names - and adding more...
Some commands are no longer needed
It uses STD::string for strings, so that it can be easily changed to use wide characters if I wanted to. It is also only SDL2 based - so everything (music, sound, networking, graphics are all for SDL).
The Windows version can use either Visual Studio or Code::Blocks, whilst Linux/Mac use Code::Blocks. This is what you saw in the video - Windows 8.1 VMPlayer running Ubuntu 14.
Once I figured that the video system wasn't telling the truth about hardware rendering (and currently its using software rendering only), everything works fine - I think.
Sprites and graphics drawing each have their own alpha mode, blend mode and colour mode, which nicely complicates things... There are 4 different blend modes now
What do you mean about Hardware rendering being not available?
Hardware rendering isn't available for virtual machines or where the drivers aren't available. This means all rendering has to be done in software rather than being done by the graphics card.
Performance wise, as long as things are kept simple (limit sprite scaling and rotating), it shouldn't be too bad.
Ah I did not get the part that you meant a virtual machine, did think hardware rendering is not possible with your lib. :-[
I've include the Linux project, and with any luck the executable should just run if you have SDL2 libraries installed. Would probably need to chmod the Starfield program too (incase zip hasn't preserved it all).
QuoteAh I did not get the part that you meant a virtual machine, did think hardware rendering is not possible with your lib
All versions should be able too - I dont have any Linux devices that allow hardware rendering unforunately.
Is there a way to check if it's hardware or software rendering?. I only ask as recently installed opensuse in vmplayer and the tron lightcycle game runs at over 250fps & that's 3d. Granted it's not the most demanding 3d but I wasn't expecting a fps that high especially only running the vm with a single core.
Lee
Have a look on this site : http://mgltools.scripps.edu/documentation/how-to/hardware-opengl
It will take you through what you can do to check. However, it does appear that VM systems lie about the information. So whilst it may say direct rendering and whatnot, it's quite possible that it isn't true!
glxinfo with no parameters also returns interesting info...
Thanks.
Typed in the info from the site you linked & got the following response
OpenGL renderer string: Gallium 0.4 on SVGA3D; build: RELEASE;
The site said if I gotMesa GLX Indirect then it is using software & not hardware, which to me points it is using hardware.
Lee
Indeed - thats what I get too.
In addition, glxinfo on its own gives :
Quotename of display: :0
display: :0 screen: 0
direct rendering: Yes
server glx vendor string: SGI
server glx version string: 1.4
server glx extensions:
GLX_ARB_create_context, GLX_ARB_create_context_profile,
GLX_ARB_fbconfig_float, GLX_ARB_framebuffer_sRGB, GLX_ARB_multisample,
GLX_EXT_create_context_es2_profile, GLX_EXT_framebuffer_sRGB,
GLX_EXT_import_context, GLX_EXT_texture_from_pixmap, GLX_EXT_visual_info,
GLX_EXT_visual_rating, GLX_MESA_copy_sub_buffer, GLX_OML_swap_method,
GLX_SGIS_multisample, GLX_SGIX_fbconfig, GLX_SGIX_pbuffer,
GLX_SGIX_visual_select_group
client glx vendor string: Mesa Project and SGI
client glx version string: 1.4
client glx extensions:
GLX_ARB_create_context, GLX_ARB_create_context_profile,
GLX_ARB_create_context_robustness, GLX_ARB_fbconfig_float,
GLX_ARB_framebuffer_sRGB, GLX_ARB_get_proc_address, GLX_ARB_multisample,
GLX_EXT_create_context_es2_profile, GLX_EXT_fbconfig_packed_float,
GLX_EXT_framebuffer_sRGB, GLX_EXT_import_context,
GLX_EXT_texture_from_pixmap, GLX_EXT_visual_info, GLX_EXT_visual_rating,
GLX_INTEL_swap_event, GLX_MESA_copy_sub_buffer,
GLX_MESA_multithread_makecurrent, GLX_MESA_query_renderer,
GLX_MESA_swap_control, GLX_OML_swap_method, GLX_OML_sync_control,
GLX_SGIS_multisample, GLX_SGIX_fbconfig, GLX_SGIX_pbuffer,
GLX_SGIX_visual_select_group, GLX_SGI_make_current_read,
GLX_SGI_swap_control, GLX_SGI_video_sync
GLX version: 1.4
GLX extensions:
GLX_ARB_create_context, GLX_ARB_create_context_profile,
GLX_ARB_fbconfig_float, GLX_ARB_framebuffer_sRGB,
GLX_ARB_get_proc_address, GLX_ARB_multisample,
GLX_EXT_create_context_es2_profile, GLX_EXT_framebuffer_sRGB,
GLX_EXT_import_context, GLX_EXT_texture_from_pixmap, GLX_EXT_visual_info,
GLX_EXT_visual_rating, GLX_MESA_copy_sub_buffer,
GLX_MESA_multithread_makecurrent, GLX_MESA_swap_control,
GLX_OML_swap_method, GLX_SGIS_multisample, GLX_SGIX_fbconfig,
GLX_SGIX_pbuffer, GLX_SGIX_visual_select_group, GLX_SGI_make_current_read,
GLX_SGI_video_sync
OpenGL vendor string: VMware, Inc.
OpenGL renderer string: Gallium 0.4 on SVGA3D; build: RELEASE;
OpenGL version string: 2.1 Mesa 10.1.3
OpenGL shading language version string: 1.20
OpenGL extensions:
GL_AMD_shader_trinary_minmax, GL_ANGLE_texture_compression_dxt3,
GL_ANGLE_texture_compression_dxt5, GL_APPLE_packed_pixels,
GL_APPLE_vertex_array_object, GL_ARB_ES2_compatibility,
GL_ARB_clear_buffer_object, GL_ARB_color_buffer_float, GL_ARB_copy_buffer,
GL_ARB_debug_output, GL_ARB_depth_texture, GL_ARB_draw_buffers,
GL_ARB_draw_elements_base_vertex, GL_ARB_explicit_attrib_location,
GL_ARB_fragment_coord_conventions, GL_ARB_fragment_program,
GL_ARB_fragment_program_shadow, GL_ARB_fragment_shader,
GL_ARB_framebuffer_object, GL_ARB_framebuffer_sRGB,
GL_ARB_get_program_binary, GL_ARB_half_float_pixel,
GL_ARB_half_float_vertex, GL_ARB_internalformat_query,
GL_ARB_invalidate_subdata, GL_ARB_map_buffer_alignment,
GL_ARB_map_buffer_range, GL_ARB_multisample, GL_ARB_multitexture,
GL_ARB_occlusion_query, GL_ARB_occlusion_query2,
GL_ARB_pixel_buffer_object, GL_ARB_point_parameters, GL_ARB_point_sprite,
GL_ARB_provoking_vertex, GL_ARB_robustness, GL_ARB_sampler_objects,
GL_ARB_shader_objects, GL_ARB_shader_texture_lod,
GL_ARB_shading_language_100, GL_ARB_shadow, GL_ARB_sync,
GL_ARB_texture_border_clamp, GL_ARB_texture_compression,
GL_ARB_texture_cube_map, GL_ARB_texture_env_add,
GL_ARB_texture_env_combine, GL_ARB_texture_env_crossbar,
GL_ARB_texture_env_dot3, GL_ARB_texture_float,
GL_ARB_texture_mirrored_repeat, GL_ARB_texture_non_power_of_two,
GL_ARB_texture_rectangle, GL_ARB_texture_storage, GL_ARB_texture_swizzle,
GL_ARB_transpose_matrix, GL_ARB_vertex_array_bgra,
GL_ARB_vertex_array_object, GL_ARB_vertex_attrib_binding,
GL_ARB_vertex_buffer_object, GL_ARB_vertex_program, GL_ARB_vertex_shader,
GL_ARB_window_pos, GL_ATI_blend_equation_separate, GL_ATI_draw_buffers,
GL_ATI_separate_stencil, GL_ATI_texture_env_combine3,
GL_ATI_texture_float, GL_EXT_abgr, GL_EXT_bgra, GL_EXT_blend_color,
GL_EXT_blend_equation_separate, GL_EXT_blend_func_separate,
GL_EXT_blend_minmax, GL_EXT_blend_subtract, GL_EXT_compiled_vertex_array,
GL_EXT_copy_texture, GL_EXT_draw_range_elements, GL_EXT_fog_coord,
GL_EXT_framebuffer_blit, GL_EXT_framebuffer_object,
GL_EXT_framebuffer_sRGB, GL_EXT_gpu_program_parameters,
GL_EXT_multi_draw_arrays, GL_EXT_packed_depth_stencil,
GL_EXT_packed_pixels, GL_EXT_pixel_buffer_object, GL_EXT_point_parameters,
GL_EXT_polygon_offset, GL_EXT_provoking_vertex, GL_EXT_rescale_normal,
GL_EXT_secondary_color, GL_EXT_separate_specular_color,
GL_EXT_shadow_funcs, GL_EXT_stencil_two_side, GL_EXT_stencil_wrap,
GL_EXT_subtexture, GL_EXT_texture, GL_EXT_texture3D,
GL_EXT_texture_compression_dxt1, GL_EXT_texture_compression_s3tc,
GL_EXT_texture_cube_map, GL_EXT_texture_edge_clamp,
GL_EXT_texture_env_add, GL_EXT_texture_env_combine,
GL_EXT_texture_env_dot3, GL_EXT_texture_filter_anisotropic,
GL_EXT_texture_lod_bias, GL_EXT_texture_object, GL_EXT_texture_rectangle,
GL_EXT_texture_sRGB, GL_EXT_texture_sRGB_decode, GL_EXT_texture_swizzle,
GL_EXT_vertex_array, GL_EXT_vertex_array_bgra,
GL_IBM_multimode_draw_arrays, GL_IBM_rasterpos_clip,
GL_IBM_texture_mirrored_repeat, GL_INGR_blend_func_separate, GL_KHR_debug,
GL_MESA_pack_invert, GL_MESA_window_pos, GL_NV_blend_square,
GL_NV_fog_distance, GL_NV_light_max_exponent, GL_NV_packed_depth_stencil,
GL_NV_primitive_restart, GL_NV_texgen_reflection,
GL_NV_texture_env_combine4, GL_NV_texture_rectangle, GL_NV_vdpau_interop,
GL_OES_EGL_image, GL_OES_read_format, GL_S3_s3tc,
GL_SGIS_generate_mipmap, GL_SGIS_texture_border_clamp,
GL_SGIS_texture_edge_clamp, GL_SGIS_texture_lod, GL_SUN_multi_draw_arrays
96 GLX Visuals
visual x bf lv rg d st colorbuffer sr ax dp st accumbuffer ms cav
id dep cl sp sz l ci b ro r g b a F gb bf th cl r g b a ns b eat
----------------------------------------------------------------------------
0x021 24 tc 0 32 0 r y . 8 8 8 8 . . 0 24 8 0 0 0 0 0 0 None
Note that it says "Direct rendering: Yes". However, I do believe it is lying, and it solely software based
I've updated Triority a fair bit now, and as you can see in the archive, there are a few few new test programs. SPRITE2MEM and MEM2SPRITE will be re-worked later on, as currently each sprite has a texture (for rendering) and a surface, which is only used for these two commands (which is a bit pointless).
I also fixed a bug whereby CPU time kept increasing when a program was minimised...
The test program will be split into two now - this post with contain the media and the next will have the programs.
Programs
My Triority system is coming along very nicely, and has some pretty interesting stuff in it now. I'm using it to write my current game (Assembloids - a video of which is here : https://www.youtube.com/watch?v=GJauenA_TlQ&list=UUBh277gKVEqpDcsqyjzMVMQ)
The source code is here : https://onedrive.live.com/redir?resid=3422b1ba7f6b8db1!951&authkey=!AIwUpVANsKdH4YE&ithint=file%2ccpp (https://onedrive.live.com/redir?resid=3422b1ba7f6b8db1!951&authkey=!AIwUpVANsKdH4YE&ithint=file%2ccpp)
Header is here : https://onedrive.live.com/redir?resid=3422b1ba7f6b8db1!949&authkey=!AF1zu3wJuQAlJPY&ithint=file%2ch (https://onedrive.live.com/redir?resid=3422b1ba7f6b8db1!949&authkey=!AF1zu3wJuQAlJPY&ithint=file%2ch)
Mappy header is here : https://onedrive.live.com/redir?resid=3422b1ba7f6b8db1!950&authkey=!AKiTGhRA66vj63Y&ithint=file%2ch (https://onedrive.live.com/redir?resid=3422b1ba7f6b8db1!950&authkey=!AKiTGhRA66vj63Y&ithint=file%2ch)
It is all SDL2 based (music, networking, text display etc), and a fair amount of GLBasic commands are implemented (although any still aren't - screen blending for example, as well as the 3D system). There are many, many new commands of course - for example there are basic (no pun intended) for particles, string padding and filling and music fading (which is performed in the background which doesn't stop the program running).
Cool. :)
Looks like your getting there, well done! :)
Started a Kickstarter campaign for it (assuming I can get them to verify me) : https://www.kickstarter.com/projects/triority/1200248071?token=657410ae (https://www.kickstarter.com/projects/triority/1200248071?token=657410ae)
I'm not really upto speed on this since this project has been going on for a long while now and I've seen and read sooooo many other things since then...
So, what advantages are there to using this over GLB?
Technically, there isn't a real advantage of this over GLBasic, especially as SDL2 isn't available for handheld devices - at the moment, that is.
You also need to be able to program in C/C++ - but thats another topic.
There are a few things that this can do which GLBasic cant : TTF fonts, which can be coloured, for example.
There is no 3D system yet unfortunately, which I would like to add.
Sooo... if this already offers less than GLB, why do you feel that people would back this on KickStarter when they can buy (or already have) GLB?
I'd back you purely to support you, but I'm not sure you'll hit your required amount through genuine backers as there's not really any incentive or improvement to an existing product. And honestly that KS just isn't selling it.
Not trying to knock you or Triority, but would it not be better to just create a lib or something for TTF (etc.) for GLB that users can purchase? You'd probably earn more with that than through this KickStarter campaign.
MrT I think Ian have reason, if triority makes the same like GLbasic, I think the people don't change for use it... I think if you sell libs like said Ian can be better, something like people do in another softs... In example in Shiva3d the people sells plugins for make the life more easy and don't think them are cheaper, sometimes are a bit expensive...
Perhaps a good point can be do an API for make things more easy, like in monkey do a library they sell in another way, and only make collisions and another things not too much complex... (Take a look to Monkey X web)
Indeed - Triority isn't really for GLBasic users - its mainly directed towards SDL2 users.
I dont expect any real support there though :)
I agree with Ian here.
Also, the kickstarter campaign is quite as spicy as it seems needed nowadays.
You are looking for very specific users.
Either way, I will support you too.
Thanks, you two :)
It could also be regarded as opening GLBasic into new and (somewhat) uncharted waters - with the exception of the App Game Kit (and GLBasic), there are no easy-to-use 3D systems. I could see a new area that GLBasic could slip into...
The Kickstater is now live!
Backed :)
Thanks for that!