lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 11.1.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2022-07-01 10:44:02 +02:00
parent b3bf75a2a1
commit c07cea1fe0
2172 changed files with 183300 additions and 123938 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/externals/g4tools/include/tools/sg/GL_action
Vendored
-660
View File
@@ -1,660 +0,0 @@
// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.
#ifndef tools_sg_GL_action
#define tools_sg_GL_action
#include "GL_manager"
#include <tools/sg/render_action>
//#include <tools/mathf>
//#include <tools/lina/matout>
namespace tools {
namespace sg {
class GL_action : public tools::sg::render_action {
TOOLS_ACTION(GL_action,tools::sg::GL_action,tools::sg::render_action)
public:
virtual void draw_vertex_array(tools::gl::mode_t a_mode,size_t a_floatn,const float* a_xyzs){
size_t num = a_floatn/3;
if(!num) return;
_draw_v(a_mode,num,a_xyzs);
}
virtual void draw_vertex_array_xy(tools::gl::mode_t a_mode,size_t a_floatn,const float* a_xys){
size_t num = a_floatn/2;
if(!num) return;
#ifdef _WIN32
float* vp = new float[num*3];
if(!vp) return;
float* pos = vp;
float* pda = (float*)a_xys;
for(size_t index=0;index<num;index++){
*pos = *pda;pos++;pda++;
*pos = *pda;pos++;pda++;
*pos = 0;pos++; //Windows GL needs a z = 0.
}
::glEnableClientState(GL_VERTEX_ARRAY);
::glVertexPointer(3,GL_FLOAT,0,vp);
::glDrawArrays(a_mode,0,(GLsizei)num);
::glDisableClientState(GL_VERTEX_ARRAY);
delete [] vp;
#else
::glEnableClientState(GL_VERTEX_ARRAY);
::glVertexPointer(2,GL_FLOAT,0,a_xys);
::glDrawArrays(a_mode,0,(GLsizei)num);
::glDisableClientState(GL_VERTEX_ARRAY);
#endif
}
virtual void draw_vertex_color_array(tools::gl::mode_t a_mode,size_t a_floatn,const float* a_xyzs,const float* a_rgbas){
// Used in atb_vertices.
// We expect a_rgbas of size : 4*(a_floatn/3)
// (then one RGBA color per 3D point).
size_t num = a_floatn/3;
if(!num) return;
_draw_vc(a_mode,num,a_xyzs,a_rgbas);
}
virtual void draw_vertex_normal_array(tools::gl::mode_t a_mode,size_t a_floatn,const float* a_xyzs,const float* a_nms){
// We expect a_nms of size : 3*(a_floatn/3)
// (then one normal per 3D point).
size_t num = a_floatn/3;
if(!num) return;
_draw_vn(a_mode,num,a_xyzs,a_nms);
}
virtual void draw_vertex_color_normal_array(tools::gl::mode_t a_mode,
size_t a_floatn,const float* a_xyzs,const float* a_rgbas,const float* a_nms){
// Used in atb_vertices.
// We expect a_nms of size : 3*(a_floatn/3)
// (then one normal per 3D point).
// We expect a_rgbas of size : 4*(a_floatn/3)
// (then one RGBA color per 3D point).
size_t num = a_floatn/3;
if(!num) return;
_draw_vcn(a_mode,num,a_xyzs,a_rgbas,a_nms);
}
/////////////////////////////////////////////////////////////////
/// texture /////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
virtual void draw_vertex_array_texture(tools::gl::mode_t a_mode,
size_t a_floatn,
const float* a_xyzs,
gstoid a_tex,
const float* a_tex_coords) {
size_t num = a_floatn/3;
if(!num) return;
//expect 2*num a_tex_coords.
::glEnable(GL_TEXTURE_2D);
m_mgr.bind_gsto(a_tex);
::glEnableClientState(GL_VERTEX_ARRAY);
::glEnableClientState(GL_TEXTURE_COORD_ARRAY);
::glVertexPointer(3,GL_FLOAT,0,a_xyzs);
::glTexCoordPointer(2,GL_FLOAT,0,a_tex_coords);
::glDrawArrays(a_mode,0,(GLsizei)num);
::glDisableClientState(GL_VERTEX_ARRAY);
::glDisableClientState(GL_TEXTURE_COORD_ARRAY);
::glBindTexture(GL_TEXTURE_2D,0);
::glDisable(GL_TEXTURE_2D);
}
virtual void draw_vertex_normal_array_texture(tools::gl::mode_t a_mode,
size_t a_floatn,
const float* a_xyzs,
const float* a_nms,
gstoid a_tex,
const float* a_tex_coords) {
size_t num = a_floatn/3;
if(!num) return;
//expect 2*num a_tex_coords.
::glEnable(GL_TEXTURE_2D);
m_mgr.bind_gsto(a_tex);
::glEnableClientState(GL_VERTEX_ARRAY);
::glEnableClientState(GL_NORMAL_ARRAY);
::glEnableClientState(GL_TEXTURE_COORD_ARRAY);
::glVertexPointer(3,GL_FLOAT,0,a_xyzs);
::glNormalPointer(GL_FLOAT,0,a_nms);
::glTexCoordPointer(2,GL_FLOAT,0,a_tex_coords);
::glDrawArrays(a_mode,0,(GLsizei)num);
::glDisableClientState(GL_NORMAL_ARRAY);
::glDisableClientState(GL_VERTEX_ARRAY);
::glDisableClientState(GL_TEXTURE_COORD_ARRAY);
::glBindTexture(GL_TEXTURE_2D,0);
::glDisable(GL_TEXTURE_2D);
}
/////////////////////////////////////////////////////////////////
/// VBO /////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
virtual void begin_gsto(gstoid a_id) {
switch(m_mgr.get_gsto_mode()){
case tools::sg::gsto_gl_vbo:{
#ifdef TOOLS_HAS_GL_VBO
m_mgr.bind_gsto(a_id);
#endif
}break;
case tools::sg::gsto_gl_list:{
#ifdef TOOLS_HAS_GL_LIST
m_gsto = a_id;
m_created = false;
m_gl_id = m_mgr.gsto_gl_list_id(a_id,m_created);
if(m_gl_id && m_created) {
::glNewList(m_gl_id,GL_COMPILE);
}
#endif
}break;
case tools::sg::gsto_memory:{
m_gsto = a_id;
}break;
}
}
virtual void end_gsto() {
switch(m_mgr.get_gsto_mode()){
case tools::sg::gsto_gl_vbo:{
#ifdef TOOLS_HAS_GL_VBO
::glBindBuffer(GL_ARRAY_BUFFER,0);
#endif
}break;
case tools::sg::gsto_gl_list:{
#ifdef TOOLS_HAS_GL_LIST
if(m_gl_id && m_created) {
::glEndList();
}
if(m_gl_id) ::glCallList(m_gl_id);
m_created = false;
m_gl_id = 0;
m_gsto = 0;
#endif
}break;
case tools::sg::gsto_memory:{
m_gsto = 0;
}break;
}
}
typedef tools::sg::bufpos bufpos;
virtual void draw_gsto_v(tools::gl::mode_t a_mode,size_t a_elems,bufpos a_pos_xyzs){
switch(m_mgr.get_gsto_mode()){
case tools::sg::gsto_gl_vbo:{
#ifdef TOOLS_HAS_GL_VBO
_draw_v(a_mode,a_elems,(char*)NULL+a_pos_xyzs);
#endif
}break;
case tools::sg::gsto_gl_list:{
#ifdef TOOLS_HAS_GL_LIST
float* buffer = m_mgr.gsto_data(m_gsto);
if(!buffer) return;
void* pos_xyzs = (char*)buffer+a_pos_xyzs;
if(m_gl_id && m_created) {
::glBegin(a_mode);
float* pos = (float*)pos_xyzs;
for(size_t index=0;index<a_elems;index++,pos+=3) {
::glVertex3f(*(pos+0),*(pos+1),*(pos+2));
}
::glEnd();
}
#endif
}break;
case tools::sg::gsto_memory:{
float* buffer = m_mgr.gsto_data(m_gsto);
if(!buffer) return;
void* pos_xyzs = (char*)buffer+a_pos_xyzs;
_draw_v(a_mode,a_elems,pos_xyzs);
}break;
}
}
virtual void draw_gsto_vc(tools::gl::mode_t a_mode,size_t a_elems,bufpos a_pos_xyzs,bufpos a_pos_rgbas){
switch(m_mgr.get_gsto_mode()){
case tools::sg::gsto_gl_vbo:{
#ifdef TOOLS_HAS_GL_VBO
_draw_vc(a_mode,a_elems,(char*)NULL+a_pos_xyzs,(char*)NULL+a_pos_rgbas);
#endif
}break;
case tools::sg::gsto_gl_list:{
#ifdef TOOLS_HAS_GL_LIST
float* buffer = m_mgr.gsto_data(m_gsto);
if(!buffer) return;
void* pos_xyzs = (char*)buffer+a_pos_xyzs;
void* pos_rgbas = (char*)buffer+a_pos_rgbas;
if(m_gl_id && m_created) {
::glBegin(a_mode);
float* pos = (float*)pos_xyzs;
float* pco = (float*)pos_rgbas;
for(size_t index=0;index<a_elems;index++,pos+=3,pco+=4) {
::glColor4f (*(pco+0),*(pco+1),*(pco+2),*(pco+3));
::glVertex3f(*(pos+0),*(pos+1),*(pos+2));
}
::glEnd();
}
#endif
}break;
case tools::sg::gsto_memory:{
float* buffer = m_mgr.gsto_data(m_gsto);
if(!buffer) return;
void* pos_xyzs = (char*)buffer+a_pos_xyzs;
void* pos_rgbas = (char*)buffer+a_pos_rgbas;
_draw_vc(a_mode,a_elems,pos_xyzs,pos_rgbas);
}break;
}
}
virtual void draw_gsto_vn(tools::gl::mode_t a_mode,size_t a_elems,bufpos a_pos_xyzs,bufpos a_pos_nms){
switch(m_mgr.get_gsto_mode()){
case tools::sg::gsto_gl_vbo:{
#ifdef TOOLS_HAS_GL_VBO
_draw_vn(a_mode,a_elems,(char*)NULL+a_pos_xyzs,(char*)NULL+a_pos_nms);
#endif
}break;
case tools::sg::gsto_gl_list:{
#ifdef TOOLS_HAS_GL_LIST
float* buffer = m_mgr.gsto_data(m_gsto);
if(!buffer) return;
void* pos_xyzs = (char*)buffer+a_pos_xyzs;
//void* pos_nms = (char*)buffer+a_pos_nms;
if(m_gl_id && m_created) {
::glBegin(a_mode);
float* pos = (float*)pos_xyzs;
for(size_t index=0;index<a_elems;index++,pos+=3) {
::glVertex3f(*(pos+0),*(pos+1),*(pos+2));
}
::glEnd();
}
#endif
}break;
case tools::sg::gsto_memory:{
float* buffer = m_mgr.gsto_data(m_gsto);
if(!buffer) return;
void* pos_xyzs = (char*)buffer+a_pos_xyzs;
void* pos_nms = (char*)buffer+a_pos_nms;
_draw_vn(a_mode,a_elems,pos_xyzs,pos_nms);
}break;
}
}
virtual void draw_gsto_vcn(tools::gl::mode_t a_mode,size_t a_elems,bufpos a_pos_xyzs,bufpos a_pos_rgbas,bufpos a_pos_nms){
switch(m_mgr.get_gsto_mode()){
case tools::sg::gsto_gl_vbo:{
#ifdef TOOLS_HAS_GL_VBO
_draw_vcn(a_mode,a_elems,(char*)NULL+a_pos_xyzs,(char*)NULL+a_pos_rgbas,(char*)NULL+a_pos_nms);
#endif
}break;
case tools::sg::gsto_gl_list:{
#ifdef TOOLS_HAS_GL_LIST
float* buffer = m_mgr.gsto_data(m_gsto);
if(!buffer) return;
void* pos_xyzs = (char*)buffer+a_pos_xyzs;
void* pos_rgbas = (char*)buffer+a_pos_rgbas;
void* pos_nms = (char*)buffer+a_pos_nms;
if(m_gl_id && m_created) {
::glBegin(a_mode);
float* pos = (float*)pos_xyzs;
float* pco = (float*)pos_rgbas;
float* pnm = (float*)pos_nms;
for(size_t index=0;index<a_elems;
index++,pos+=3,pco+=4,pnm+=3) {
::glVertex3f(*(pos+0),*(pos+1),*(pos+2));
::glColor4f (*(pco+0),*(pco+1),*(pco+2),*(pco+3));
::glNormal3f(*(pnm+0),*(pnm+1),*(pnm+2));
}
::glEnd();
}
#endif
}break;
case tools::sg::gsto_memory:{
float* buffer = m_mgr.gsto_data(m_gsto);
if(!buffer) return;
void* pos_xyzs = (char*)buffer+a_pos_xyzs;
void* pos_rgbas = (char*)buffer+a_pos_rgbas;
void* pos_nms = (char*)buffer+a_pos_nms;
_draw_vcn(a_mode,a_elems,pos_xyzs,pos_rgbas,pos_nms);
}break;
}
}
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
virtual void clear_color(float a_r,float a_g,float a_b,float a_a){
::glClearColor(a_r,a_g,a_b,a_a);
::glClear(GL_COLOR_BUFFER_BIT);
}
virtual void color4f(float a_r,float a_g,float a_b,float a_a){
::glColor4f(a_r,a_g,a_b,a_a);
}
virtual void line_width(float a_v){::glLineWidth(a_v);}
virtual void point_size(float a_v){::glPointSize(a_v);}
virtual void set_polygon_offset(bool a_v) {
if(a_v) ::glEnable(GL_POLYGON_OFFSET_FILL);
else ::glDisable(GL_POLYGON_OFFSET_FILL);
::glPolygonOffset(1.,1.);
}
virtual void normal(float a_x,float a_y,float a_z) {
::glNormal3f(a_x,a_y,a_z);
}
virtual void set_winding(tools::sg::winding_type a_v) {
if(a_v==tools::sg::winding_ccw)
::glFrontFace(GL_CCW);
else
::glFrontFace(GL_CW);
}
virtual void set_shade_model(tools::sg::shade_type a_v) {
if(a_v==tools::sg::shade_smooth)
::glShadeModel(GL_SMOOTH);
else
::glShadeModel(GL_FLAT);
}
virtual void set_cull_face(bool a_on) {
if(a_on) ::glEnable(GL_CULL_FACE);
else ::glDisable(GL_CULL_FACE);
}
virtual void set_point_smooth(bool a_on) {
if(a_on) ::glEnable(GL_POINT_SMOOTH);
else ::glDisable(GL_POINT_SMOOTH);
}
virtual void set_line_smooth(bool a_on) {
if(a_on) ::glEnable(GL_LINE_SMOOTH);
else ::glDisable(GL_LINE_SMOOTH);
}
virtual void set_depth_test(bool a_on) {
if(a_on) ::glEnable(GL_DEPTH_TEST);
else ::glDisable(GL_DEPTH_TEST);
}
virtual void load_proj_matrix(const tools::mat4f& a_mtx) {
::glMatrixMode(GL_PROJECTION);
::glLoadMatrixf(a_mtx.data());
}
virtual void load_model_matrix(const tools::mat4f& a_mtx) {
::glMatrixMode(GL_MODELVIEW);
::glLoadMatrixf(a_mtx.data());
/*
tools::mat4f tmp(a_mtx);
tmp.no_translate();
tools::mat4f normal_matrix;
if(!tmp.invert(normal_matrix)) {
m_out << "tools::WebGL::render::load_model_matrix :"
<< " can't invert model matrix."
<< std::endl;
}
normal_matrix.transpose();
tools::mat4f to_check(a_mtx);
to_check.no_translate();
float fepsilon = 1e-10;
if(!normal_matrix.equal_prec(to_check,fepsilon,tools::ffabs)) {
mat_dump(m_out,"problem with normal_matrix ",normal_matrix);
mat_dump(m_out,"expected",to_check);
}
*/
}
virtual unsigned int max_lights() {return GL_MAX_LIGHTS;}
virtual void enable_light(unsigned int a_light,
float a_dx,float a_dy,float a_dz,
float a_r,float a_g,float a_b,float a_a){
::glEnable(GL_LIGHTING);
GLenum light = GL_LIGHT0+a_light;
//::printf("debug : GL_MAX_LIGHTS %d\n",GL_MAX_LIGHTS);
float params[4];
params[0] = -a_dx;
params[1] = -a_dy;
params[2] = -a_dz;
params[3] = 0; //0 tells that it is a directional light.
::glLightfv(light,GL_POSITION,params);
//params[0] = a_dir[0];
//params[1] = a_dir[1];
//params[2] = a_dir[2];
//::glLightfv(light,GL_SPOT_DIRECTION,params);
params[0] = a_r;
params[1] = a_g;
params[2] = a_b;
params[3] = a_a;
::glLightfv(light,GL_DIFFUSE,params);
::glLightfv(light,GL_SPECULAR,params); //coin/SoDirectionalLight does that.
params[0] = 0;
params[1] = 0;
params[2] = 0;
params[3] = 1;
::glLightfv(light,GL_AMBIENT,params); //coin/SoDirectionalLight does that.
// coin/SoDirectionalLight does the below :
::glLightf(light, GL_SPOT_EXPONENT, 0.0);
::glLightf(light, GL_SPOT_CUTOFF, 180.0);
::glLightf(light, GL_CONSTANT_ATTENUATION, 1);
::glLightf(light, GL_LINEAR_ATTENUATION, 0);
::glLightf(light, GL_QUADRATIC_ATTENUATION, 0);
//::printf("debug : GL_MAX_LIGHTS %d\n",GL_MAX_LIGHTS);
::glEnable(light);
}
virtual void set_lighting(bool a_on) {
if(a_on) ::glEnable(GL_LIGHTING);
else ::glDisable(GL_LIGHTING);
}
virtual void set_blend(bool a_on) {
if(a_on) ::glEnable(GL_BLEND);
else ::glDisable(GL_BLEND);
}
virtual void restore_state(unsigned int a_ret_num_light) {
const tools::sg::state& _state = state();
::glMatrixMode(GL_PROJECTION);
::glLoadMatrixf(_state.m_proj.data());
::glMatrixMode(GL_MODELVIEW);
::glLoadMatrixf(_state.m_model.data());
if(_state.m_GL_LIGHTING) ::glEnable(GL_LIGHTING);
else ::glDisable(GL_LIGHTING);
if(_state.m_GL_DEPTH_TEST) ::glEnable(GL_DEPTH_TEST);
else ::glDisable(GL_DEPTH_TEST);
if(_state.m_GL_CULL_FACE) ::glEnable(GL_CULL_FACE);
else ::glDisable(GL_CULL_FACE);
if(_state.m_GL_POINT_SMOOTH) ::glEnable(GL_POINT_SMOOTH);
else ::glDisable(GL_POINT_SMOOTH);
if(_state.m_GL_LINE_SMOOTH) ::glEnable(GL_LINE_SMOOTH);
else ::glDisable(GL_LINE_SMOOTH);
if(_state.m_GL_POLYGON_OFFSET_FILL) ::glEnable(GL_POLYGON_OFFSET_FILL);
else ::glDisable(GL_POLYGON_OFFSET_FILL);
if(_state.m_GL_TEXTURE_2D) ::glEnable(GL_TEXTURE_2D);
else ::glDisable(GL_TEXTURE_2D);
if(_state.m_GL_BLEND) ::glEnable(GL_BLEND);
else ::glDisable(GL_BLEND);
if(_state.m_winding==tools::sg::winding_ccw) {
::glFrontFace(GL_CCW);
} else {
::glFrontFace(GL_CW);
}
if(_state.m_shade_model==tools::sg::shade_smooth)
::glShadeModel(GL_SMOOTH);
else
::glShadeModel(GL_FLAT);
::glColor4f(_state.m_color.r(),
_state.m_color.g(),
_state.m_color.b(),
_state.m_color.a());
::glNormal3f(_state.m_normal.x(),
_state.m_normal.y(),
_state.m_normal.z());
// The "return of separator" state had ret_num_light.
// The restored state has m_light.
// We have to glDisable lights with index in [m_light,ret_num_light-1]
for(unsigned int index=_state.m_light;index<a_ret_num_light;index++) {
::glDisable(GL_LIGHT0+index);
}
::glLineWidth(_state.m_line_width);
::glPointSize(_state.m_point_size);
#if TARGET_OS_IPHONE
// GL-ES
#elif defined(ANDROID)
// GL-ES
#else
::glDisable(GL_POLYGON_STIPPLE); //CoinGL : reading a .wrl having Material::transparency may enable GL_POLYGON_STIPPLE.
#endif
}
virtual tools::sg::render_manager& render_manager() {return m_mgr;}
public:
GL_action(GL_manager& a_mgr,std::ostream& a_out,unsigned int a_ww,unsigned int a_wh)
:parent(a_out,a_ww,a_wh)
,m_mgr(a_mgr)
,m_gsto(0)
#ifdef TOOLS_HAS_GL_LIST
,m_created(false)
,m_gl_id(0)
#endif
{}
virtual ~GL_action(){}
public:
GL_action(const GL_action& a_from)
:parent(a_from)
,m_mgr(a_from.m_mgr)
,m_gsto(0)
#ifdef TOOLS_HAS_GL_LIST
,m_created(false)
,m_gl_id(0)
#endif
{}
GL_action& operator=(const GL_action& a_from){
render_action::operator=(a_from);
m_gsto = 0;
#ifdef TOOLS_HAS_GL_LIST
m_created = false;
m_gl_id = 0;
#endif
return *this;
}
protected:
void _draw_v(tools::gl::mode_t a_mode,size_t a_elems,const void* a_pos_xyzs){
::glEnableClientState(GL_VERTEX_ARRAY);
::glVertexPointer(3,GL_FLOAT,0,a_pos_xyzs);
::glDrawArrays(a_mode,0,(GLsizei)a_elems);
::glDisableClientState(GL_VERTEX_ARRAY);
}
void _draw_vc(tools::gl::mode_t a_mode,size_t a_elems,const void* a_pos_xyzs,const void* a_pos_rgbas){
::glEnableClientState(GL_VERTEX_ARRAY);
::glEnableClientState(GL_COLOR_ARRAY);
::glVertexPointer(3,GL_FLOAT,0,a_pos_xyzs);
::glColorPointer(4,GL_FLOAT,0,a_pos_rgbas);
::glDrawArrays(a_mode,0,(GLsizei)a_elems);
::glDisableClientState(GL_COLOR_ARRAY);
::glDisableClientState(GL_VERTEX_ARRAY);
}
void _draw_vn(tools::gl::mode_t a_mode,size_t a_elems,const void* a_pos_xyzs,const void* a_pos_nms){
::glEnableClientState(GL_VERTEX_ARRAY);
::glEnableClientState(GL_NORMAL_ARRAY);
::glVertexPointer(3,GL_FLOAT,0,a_pos_xyzs);
::glNormalPointer(GL_FLOAT,0,a_pos_nms);
::glDrawArrays(a_mode,0,(GLsizei)a_elems);
::glDisableClientState(GL_NORMAL_ARRAY);
::glDisableClientState(GL_VERTEX_ARRAY);
}
void _draw_vcn(tools::gl::mode_t a_mode,size_t a_elems,const void* a_pos_xyzs,const void* a_pos_rgbas,const void* a_pos_nms){
::glEnableClientState(GL_VERTEX_ARRAY);
::glEnableClientState(GL_COLOR_ARRAY);
::glEnableClientState(GL_NORMAL_ARRAY);
::glVertexPointer(3,GL_FLOAT,0,a_pos_xyzs);
::glColorPointer(4,GL_FLOAT,0,a_pos_rgbas);
::glNormalPointer(GL_FLOAT,0,a_pos_nms);
::glDrawArrays(a_mode,0,(GLsizei)a_elems);
::glDisableClientState(GL_COLOR_ARRAY);
::glDisableClientState(GL_NORMAL_ARRAY);
::glDisableClientState(GL_VERTEX_ARRAY);
}
protected:
GL_manager& m_mgr;
gstoid m_gsto;
#ifdef TOOLS_HAS_GL_LIST
bool m_created;
gstoid m_gl_id;
#endif
};
}}
#endif
source/externals/g4tools/include/tools/sg/GL_manager
Vendored
-696
View File
@@ -1,696 +0,0 @@
// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.
#ifndef tools_sg_GL_manager
#define tools_sg_GL_manager
#include "gl"
#include "../glbuf"
#include <tools/sg/render_manager>
#include <tools/mapmanip>
#include <tools/carray>
#include <cmath> //::sqrt
#ifdef TOOLS_MEM
#include <tools/mem>
#endif
namespace tools {
namespace sg {
class GL_manager : public virtual tools::sg::render_manager {
typedef tools::sg::render_manager parent;
public:
TOOLS_SCLASS(tools::sg::GL_manager)
virtual void* cast(const std::string& a_class) const {
if(void* p = tools::cmp_cast<GL_manager>(this,a_class)) {return p;}
else return 0;
}
public:
virtual bool begin_render(int a_x,int a_y,unsigned int a_ww,unsigned int a_wh,
float a_r,float a_g,float a_b,float a_a,bool a_clear = true) {
gl_clear_errors();
#if TARGET_OS_IPHONE
#elif defined(ANDROID)
#elif _WIN32
#elif __APPLE__ // Cocoa
// to avoid a 0x506 error message :
#ifdef TOOLS_HAS_GL_VBO
#if GL_ARB_framebuffer_object
if(::glCheckFramebufferStatus(GL_FRAMEBUFFER)!=GL_FRAMEBUFFER_COMPLETE) {
//m_out << "tools::sg::GL_manager::begin_render :"
// << " frame buffer not complete."
// << std::endl;
return false;
}
#endif //GL_ARB_framebuffer_object
#endif //TOOLS_HAS_GL_VBO
#else
#endif
// WARNING : the values set here must match the default values in sg::state.
// Antialiasing :
#if TARGET_OS_IPHONE
#elif defined(ANDROID)
::glEnable(GL_MULTISAMPLE);
#elif _WIN32
#elif __APPLE__
::glEnable(GL_MULTISAMPLE); //Cocoa
#else
#endif
/* NOTE : not GL-ES :
// ::glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
// The upper is cruely lacking with povama solid+light.
// ::glEnable(GL_LINE_STIPPLE);
::glDisable(GL_POLYGON_SMOOTH);
::glAccum(GL_LOAD,1.0f);
::glAccum(GL_RETURN,1.0f);
::glReadBuffer(GL_FRONT);
NOTE : GL_POLYGON_SMOOTH is here on Cocoa/AGL, Windows/WGL but it
does nothing.
*/
#if TARGET_OS_IPHONE
// GL-ES
#elif defined(ANDROID)
// GL-ES
#else
::glDisable(GL_POLYGON_STIPPLE); //CoinGL : reading a .wrl having Material::transparency may enable GL_POLYGON_STIPPLE.
#endif
/*
::printf("debug : is enabled %d\n",::glIsEnabled(GL_COLOR_MATERIAL));
{GLfloat v[4];
::glGetMaterialfv(GL_FRONT,GL_AMBIENT,v);
::printf("debug : ambient : %g %g %g %g\n",v[0],v[1],v[2],v[3]);}
{GLfloat v[4];
::glGetMaterialfv(GL_FRONT,GL_DIFFUSE,v);
::printf("debug : diffuse : %g %g %g %g\n",v[0],v[1],v[2],v[3]);}
{GLfloat v[4];
::glGetMaterialfv(GL_FRONT,GL_SPECULAR,v);
::printf("debug : specular : %g %g %g %g\n",v[0],v[1],v[2],v[3]);}
{GLfloat v[4];
::glGetMaterialfv(GL_FRONT,GL_EMISSION,v);
::printf("debug : emission : %g %g %g %g\n",v[0],v[1],v[2],v[3]);}
{GLfloat shine;
::glGetMaterialfv(GL_FRONT,GL_SHININESS,&shine);
::printf("debug : shine : %g\n",shine);}
debug : is enabled 0
debug : ambient : 0.2 0.2 0.2 1
debug : diffuse : 0.8 0.8 0.8 1
debug : specular : 0 0 0 1
debug : emission : 0 0 0 1
debug : shine : 0
*/
::glEnable(GL_NORMALIZE);
::glShadeModel(GL_FLAT);
//::glShadeModel(GL_SMOOTH);
// GL-ES : ::glMaterialfv does not work. We then use :
// ::glEnable(GL_COLOR_MATERIAL) and ::glColor.
//::glColorMaterial(GL_FRONT, GL_DIFFUSE); //?
::glEnable(GL_COLOR_MATERIAL);
/*
debug : is enabled 1
debug : ambient : 1 1 1 1
debug : diffuse : 1 1 1 1
debug : specular : 0 0 0 1
debug : emission : 0 0 0 1
debug : shine : 0
*/
// to handle transparency (same as SoGLRenderAction::SCREEN_DOOR ?) :
//::glEnable(GL_BLEND);
// NOTE : with Cocoa+AppleGL on macOS-10.14 (Mojave), it appears that points are blended ! (Even if alpha color is 1).
// Seen with some simulated catalog of galaxies done for LSST/DC2.
// To master this, we disable GL_BLEND by default. Then people wanting some transparency have to
// use the tools::sg::blend node in their scene graph.
::glDisable(GL_BLEND); //must be in sync with tools::sg::state.m_GL_BLEND and sg::blend node default.
::glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
//WARNING : the below glEnable/glDisable corresponds
// to defaults in tools::sg::state.
::glEnable(GL_DEPTH_TEST);
::glDisable(GL_LIGHTING);
::glFrontFace(GL_CCW);
::glEnable(GL_CULL_FACE);
::glDisable(GL_POLYGON_OFFSET_FILL);
::glDisable(GL_TEXTURE_2D);
::glDisable(GL_POINT_SMOOTH);
::glPointSize(1);
::glDisable(GL_LINE_SMOOTH); //NOTE : it does not work on all platforms !
::glLineWidth(1);
::glViewport(a_x,a_y,a_ww,a_wh);
// NOTE : iOS : glScissor logic does not work properly with Apple multisampling.
// But it appears that it is not needed for VR split views.
// Here a combination glViewport+[correct camera lrbt] does the clipping job (???).
// (But the clear color should be the same for both views).
//::glEnable(GL_SCISSOR_TEST);
//::glScissor(a_x,a_y,a_ww,a_wh);
//NOTE : a=0 coworks with the below logic to handle transparent background.
if(a_clear) {
::glClearColor(a_r,a_g,a_b,0);
::glClear(GL_COLOR_BUFFER_BIT);
::glClear(GL_DEPTH_BUFFER_BIT);
}
//WARNING : Android, iPhone : only one glPushMatrix ok !
::glMatrixMode(GL_PROJECTION);
::glLoadIdentity();
//WARNING : we take the convention that the current mode is MODELVIEW
::glMatrixMode(GL_MODELVIEW);
::glLoadIdentity();
//m_clear_color.set_a(0.2);
// to handle a transparent background :
//NOTE : not tested on Android and iOS.
// dst color :
// cr * alpha + cr * (1-alpha) = cr
// cg * alpha + cg * (1-alpha) = cg
// cb * alpha + cb * (1-alpha) = cb
// alpha*alpha + 0 * (1-alpha) = ca => alpha = sqrt(ca)
{::glColor4f(a_r,a_g,a_b,::sqrt(a_a));
float xyzs[12];
xyzs[0] = -1;xyzs[ 1] = -1;xyzs[ 2] = 0;
xyzs[3] = 1;xyzs[ 4] = -1;xyzs[ 5] = 0;
xyzs[6] = 1;xyzs[ 7] = 1;xyzs[ 8] = 0;
xyzs[9] = -1;xyzs[10] = 1;xyzs[11] = 0;
::glDisable(GL_DEPTH_TEST);
::glEnableClientState(GL_VERTEX_ARRAY);
::glVertexPointer(3,GL_FLOAT,0,xyzs);
::glDrawArrays(GL_TRIANGLE_FAN,0,4);
::glDisableClientState(GL_VERTEX_ARRAY);
::glEnable(GL_DEPTH_TEST);}
return true;
}
virtual void end_render() {
::glFinish();
gl_dump_if_errors(m_out,"tools::sg::GL_manager::end_render :");
}
////////////////////////////////////////////////
/// texture : //////////////////////////////////
////////////////////////////////////////////////
virtual unsigned int create_texture(const tools::img_byte& a_img,bool a_NEAREST) {
unsigned int gl_id;
::glGenTextures(1,&gl_id);
if(!gl_id) return 0;
#ifdef TOOLS_MEM
tools::mem::increment(tools::s_tex().c_str());
#endif
unsigned int gsto_size = a_img.size();
::glBindTexture(GL_TEXTURE_2D,gl_id);
bool status = true;
{int sz;
::glGetIntegerv(GL_MAX_TEXTURE_SIZE,&sz);
// MacBookPro : it returns 8192.
// Android : it returns 2048.
// iPad1 : it returns 2048.
// iPod : it returns ?
//::printf("debug : GL_MAX_TEXTURE_SIZE : %d\n",sz);
tools::img_byte res;
if(!sz) {
m_out << "tools::sg::gl::tex_img : warning : GL_MAX_TEXTURE_SIZE is zero." << std::endl;
status = gl_tex_img(m_out,a_img);
} else {
if(a_img.check_gl_limit(sz,res)) {
if(res.is_empty()) { //a_img does not exceed.
status = gl_tex_img(m_out,a_img);
} else {
m_out << "tools::sg::gl::tex_img : warning : img size > GL_MAX_TEXTURE_SIZE (" << sz << ")." << std::endl;
status = gl_tex_img(m_out,res);
gsto_size = res.size();
}
} else {
m_out << "tools::sg::gl::tex_img :"
<< " warning : img size > GL_MAX_TEXTURE_SIZE (" << sz << ") but can't reduce."
<< std::endl;
status = false;
}}}
if(a_NEAREST) {
::glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST); //good to see astro images pixels.
::glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST); //idem.
} else {
::glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
::glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
}
::glBindTexture(GL_TEXTURE_2D,0);
if(!status) {
gl_dump_if_errors(m_out,"tools::sg::GL_manager::create_texture (1) :");
::glDeleteTextures(1,&gl_id);
#ifdef TOOLS_MEM
tools::mem::decrement(tools::s_tex().c_str());
#endif
gl_id = 0;
gl_clear_errors();
return 0;
}
if(gl_dump_if_errors(m_out,"tools::sg::GL_manager::create_texture (2) :")) {
::glDeleteTextures(1,&gl_id);
#ifdef TOOLS_MEM
tools::mem::decrement(tools::s_tex().c_str());
#endif
gl_id = 0;
gl_clear_errors();
return 0;
}
unsigned int _id = m_gen_id;m_gen_id++;
m_gstos[_id] = new gsto_t(gsto_t::kind_texture,gl_id,gsto_size,0);
return _id;
}
////////////////////////////////////////////////
/// VBO ////////////////////////////////////////
////////////////////////////////////////////////
virtual unsigned int create_gsto_from_data(size_t a_floatn,const float* a_data) {
if(!a_floatn) return 0;
switch(m_gsto_mode) {
case tools::sg::gsto_gl_vbo:{
#ifdef TOOLS_HAS_GL_VBO
unsigned int gl_id = 0;
::glGenBuffers(1,&gl_id);
if(!gl_id) {
if(!m_warned) {
m_warned = true;
m_out << "tools::sg::GL_manager::create_gsto_from_data : glGenBuffers failed ()." << std::endl;
}
return 0;
}
#ifdef TOOLS_MEM
tools::mem::increment(tools::s_gsto().c_str());
#endif
::glBindBuffer(GL_ARRAY_BUFFER,gl_id);
::glBufferData(GL_ARRAY_BUFFER,
a_floatn*sizeof(float),a_data,
GL_STATIC_DRAW);
::glBindBuffer(GL_ARRAY_BUFFER,0);
if(gl_dump_if_errors(m_out,"tools::sg::GL_manager::create_gsto_from_data :")) {
::glDeleteBuffers(1,&gl_id);
#ifdef TOOLS_MEM
tools::mem::decrement(tools::s_gsto().c_str());
#endif
gl_id = 0;
gl_clear_errors();
return 0;
}
unsigned int _id = m_gen_id;m_gen_id++;
m_gstos[_id] = new gsto_t(gsto_t::kind_buffer,gl_id,a_floatn*sizeof(float),0);
return _id;
#else //!TOOLS_HAS_GL_VBO
m_out << "tools::sg::GL_manager::create_gsto_from_data :"
<< " gsto mode is gl_vbo but class not compiled with TOOLS_HAS_GL_VBO."
<< std::endl;
return 0;
#endif //TOOLS_HAS_GL_VBO
}break;
case tools::sg::gsto_gl_list:{
unsigned int gl_id = 0;
unsigned int _id = m_gen_id;m_gen_id++;
m_gstos[_id] = new gsto_t(gsto_t::kind_list,gl_id,a_floatn*sizeof(float),a_data);
return _id;
}break;
case tools::sg::gsto_memory:{
unsigned int gl_id = 0;
unsigned int _id = m_gen_id;m_gen_id++;
m_gstos[_id] = new gsto_t(gsto_t::kind_memory,gl_id,a_floatn*sizeof(float),a_data);
return _id;
}break;
}
return 0;
}
virtual bool is_gsto_id_valid(unsigned int a_id) const {
std::map<unsigned int,gsto_t*>::const_iterator it = m_gstos.find(a_id);
if(it==m_gstos.end()) return false;
return (*it).second->is_valid();
}
virtual void delete_gsto(unsigned int a_id){
tools::delete_key<unsigned int,gsto_t>(m_gstos,a_id);
}
////////////////////////////////////////////////////////
////////////////////////////////////////////////////////
////////////////////////////////////////////////////////
float* gsto_data(unsigned int a_id) const {
std::map<unsigned int,gsto_t*>::const_iterator it = m_gstos.find(a_id);
if(it==m_gstos.end()) return 0;
return (*it).second->m_data;
}
unsigned int gsto_gl_list_id(unsigned int a_id,bool& a_created) const {
std::map<unsigned int,gsto_t*>::const_iterator it = m_gstos.find(a_id);
if(it==m_gstos.end()) {a_created = false;return 0;}
if((*it).second->m_kind!=gsto_t::kind_list) {a_created = false;return 0;}
if((*it).second->m_gl_id) {
a_created = false;
return (*it).second->m_gl_id;
} else {
#ifdef TOOLS_HAS_GL_LIST
unsigned int _id = ::glGenLists(1);
if(!_id) {a_created = false;return 0;}
#ifdef TOOLS_MEM
tools::mem::increment(tools::s_gsto().c_str());
#endif
a_created = true;
(*it).second->m_gl_id = _id;
return _id;
#else
a_created = false;
return 0;
#endif
}
}
////////////////////////////////////////////////////////
////////////////////////////////////////////////////////
////////////////////////////////////////////////////////
virtual tools::sg::gsto_mode get_gsto_mode() const {return m_gsto_mode;}
virtual void set_gsto_mode(tools::sg::gsto_mode a_v) {
if(a_v==m_gsto_mode) return;
tools::safe_clear<unsigned int,gsto_t>(m_gstos);
switch(a_v) {
case tools::sg::gsto_gl_vbo:{
#ifdef TOOLS_HAS_GL_VBO
m_gsto_mode = a_v;
#else
m_gsto_mode = tools::sg::gsto_memory;
#endif
}break;
case tools::sg::gsto_gl_list:{
#ifdef TOOLS_HAS_GL_LIST
m_gsto_mode = a_v;
#else
m_gsto_mode = tools::sg::gsto_memory;
#endif
}break;
case tools::sg::gsto_memory:{
m_gsto_mode = tools::sg::gsto_memory;
}break;
}
}
virtual void available_gsto_modes(std::vector<std::string>& a_vs) {
a_vs.clear();
#ifdef TOOLS_HAS_GL_VBO
a_vs.push_back(tools::sg::s_gsto_gl_vbo());
#endif
#ifdef TOOLS_HAS_GL_LIST
a_vs.push_back(tools::sg::s_gsto_gl_list());
#endif
a_vs.push_back(tools::sg::s_gsto_memory());
}
virtual void available_not_memory_gsto_mode(std::string& a_v) const {
a_v.clear();
#ifdef TOOLS_HAS_GL_VBO
a_v = tools::sg::s_gsto_gl_vbo();
#endif
#ifdef TOOLS_HAS_GL_LIST
if(a_v.empty()) a_v = tools::sg::s_gsto_gl_list();
#endif
}
virtual size_t used_texture_memory() const {
size_t sz = 0;
std::map<unsigned int,gsto_t*>::const_iterator it;
for(it=m_gstos.begin();it!=m_gstos.end();++it) {
if((*it).second->m_kind==gsto_t::kind_texture) sz += (*it).second->m_size;
}
return sz;
}
virtual size_t gstos_size() const {
size_t sz = 0;
std::map<unsigned int,gsto_t*>::const_iterator it;
for(it=m_gstos.begin();it!=m_gstos.end();++it) sz += (*it).second->m_size;
return sz;
}
public:
GL_manager(std::ostream& a_out)
:m_out(a_out)
,m_gen_id(1)
#ifdef TOOLS_HAS_GL_VBO
,m_gsto_mode(tools::sg::gsto_gl_vbo) //priority to GL VBOs.
#elif TOOLS_HAS_GL_LIST
,m_gsto_mode(tools::sg::gsto_gl_list)
#else
,m_gsto_mode(tools::sg::gsto_memory)
#endif
,m_warned(false)
{}
virtual ~GL_manager(){
tools::safe_clear<unsigned int,gsto_t>(m_gstos);
}
public:
GL_manager(const GL_manager& a_from)
:parent(a_from)
,m_out(a_from.m_out)
,m_gen_id(a_from.m_gen_id)
,m_gsto_mode(a_from.m_gsto_mode)
,m_warned(false)
{}
GL_manager& operator=(const GL_manager& a_from){
if(&a_from==this) return *this;
m_gen_id = a_from.m_gen_id;
m_gsto_mode = a_from.m_gsto_mode;
tools::safe_clear<unsigned int,gsto_t>(m_gstos);
m_warned = false;
return *this;
}
public:
void bind_gsto(unsigned int a_id) {
std::map<unsigned int,gsto_t*>::const_iterator it = m_gstos.find(a_id);
if(it==m_gstos.end()) return;
(*it).second->bind();
}
void delete_gstos() {
tools::safe_clear<unsigned int,gsto_t>(m_gstos);
}
public:
static unsigned char* get_rgbas(unsigned int a_w,unsigned int a_h) {
//WARNING : it does OpenGL. Under Android it should be executed
// in the OpenGL thread.
//NOTE : Android, iOS : RGB produces a black image.
unsigned char* rgbas = new unsigned char[4 * a_w * a_h];
if(!rgbas) return 0;
::glPixelStorei(GL_PACK_ALIGNMENT,1); //needed with Cocoa.
::glReadPixels(0,0,a_w,a_h,GL_RGBA,GL_UNSIGNED_BYTE,rgbas);
/*{size_t number = 4 * a_w * a_h;
size_t count_not_255 = 0;
for(size_t item=3;item<number;item+=4) {
unsigned char a = rgbas[item];
if(a!=255) {
::printf("%lu : %d\n",item,a);
count_not_255++;
rgbas[item] = 255;
}
}
::printf("not_255 : %lu\n",count_not_255);}*/
return rgbas;
}
#if defined(TARGET_OS_IPHONE) || defined(ANDROID)
static unsigned char* get_rgbs(unsigned int a_w,unsigned int a_h) {
unsigned char* rgbas = get_rgbas(a_w,a_h);
if(!rgbas) return 0;
unsigned char* rgbs = tools::_4s_to_3s<unsigned char,unsigned int>(rgbas,a_w,a_h);
delete [] rgbas;
return rgbs;
}
#else
static unsigned char* get_rgbs(unsigned int a_w,unsigned int a_h) {
//WARNING : it does OpenGL. Under Android it should be executed
// in the OpenGL thread.
//NOTE : Android, iOS : RGB produces a black image.
unsigned char* rgbs = new unsigned char[3 * a_w * a_h];
if(!rgbs) return 0;
::glPixelStorei(GL_PACK_ALIGNMENT,1); //needed with Cocoa.
::glReadPixels(0,0,a_w,a_h,GL_RGB,GL_UNSIGNED_BYTE,rgbs);
return rgbs;
}
#endif
protected:
std::ostream& m_out;
class gsto_t {
TOOLS_SCLASS(GL_manager::gsto_t)
public:
enum kind {
kind_texture,
kind_buffer,
kind_list,
kind_memory
};
public:
gsto_t(kind a_kind,int a_gl_id,size_t a_size,const float* a_data)
:m_gl_id(a_gl_id)
,m_kind(a_kind)
,m_size(a_size)
,m_data(0)
{
#ifdef TOOLS_MEM
tools::mem::increment(s_class().c_str());
#endif
if(a_data) {
size_t num = m_size/sizeof(float);
m_data = new float[num];
#ifdef TOOLS_MEM
tools::mem::increment(tools::s_new().c_str());
#endif
::memcpy(m_data,a_data,m_size);
}
}
virtual ~gsto_t() {
if(m_kind==kind_texture) {
::glDeleteTextures(1,&m_gl_id);
#ifdef TOOLS_MEM
tools::mem::decrement(tools::s_tex().c_str());
#endif
} else if(m_kind==kind_buffer) {
#ifdef TOOLS_HAS_GL_VBO
::glDeleteBuffers(1,&m_gl_id);
#ifdef TOOLS_MEM
tools::mem::decrement(tools::s_gsto().c_str());
#endif
#endif
} else if(m_kind==kind_list) {
if(m_gl_id) {
#ifdef TOOLS_HAS_GL_LIST
::glDeleteLists(m_gl_id,1);
#ifdef TOOLS_MEM
tools::mem::decrement(tools::s_gsto().c_str());
#endif
#endif
}
}
if(m_data) {
delete [] m_data;
#ifdef TOOLS_MEM
tools::mem::decrement(tools::s_new().c_str());
#endif
}
#ifdef TOOLS_MEM
tools::mem::decrement(s_class().c_str());
#endif
}
private:
gsto_t(const gsto_t& a_from)
:m_gl_id(a_from.m_gl_id)
,m_kind(a_from.m_kind)
,m_size(a_from.m_size)
,m_data(0)
{
#ifdef TOOLS_MEM
tools::mem::increment(s_class().c_str());
#endif
if(a_from.m_data) {
size_t num = m_size/sizeof(float);
m_data = new float[num];
#ifdef TOOLS_MEM
tools::mem::increment(tools::s_new().c_str());
#endif
::memcpy(m_data,a_from.m_data,m_size);
}
}
gsto_t& operator=(const gsto_t& a_from){
if(&a_from==this) return *this;
m_gl_id = a_from.m_gl_id;
m_kind = a_from.m_kind;
m_size = a_from.m_size;
if(m_data) {
delete [] m_data;
#ifdef TOOLS_MEM
tools::mem::decrement(tools::s_new().c_str());
#endif
m_data = 0;
}
if(a_from.m_data) {
size_t num = m_size/sizeof(float);
m_data = new float[num];
#ifdef TOOLS_MEM
tools::mem::increment(tools::s_new().c_str());
#endif
::memcpy(m_data,a_from.m_data,m_size);
}
return *this;
}
public:
bool is_valid() const {
if(m_kind==kind_texture) {
return (::glIsTexture(m_gl_id)==GL_TRUE?true:false);
} else if(m_kind==kind_buffer) {
#ifdef TOOLS_HAS_GL_VBO
return (::glIsBuffer(m_gl_id)==GL_TRUE?true:false);
#endif
} else if(m_kind==kind_list) {
#ifdef TOOLS_HAS_GL_LIST
return (::glIsList(m_gl_id)==GL_TRUE?true:false);
#endif
} else if(m_kind==kind_memory) {
return true;
}
return false;
}
void bind() const {
if(m_kind==kind_texture) {
::glBindTexture(GL_TEXTURE_2D,m_gl_id);
} else if(m_kind==kind_buffer) {
#ifdef TOOLS_HAS_GL_VBO
::glBindBuffer(GL_ARRAY_BUFFER,m_gl_id);
#endif
}
}
public:
unsigned int m_gl_id;
kind m_kind;
size_t m_size;
float* m_data;
};
std::map<unsigned int,gsto_t*> m_gstos;
bool m_gsto_on_card;
unsigned int m_gen_id;
tools::sg::gsto_mode m_gsto_mode;
bool m_warned;
};
}}
#endif
source/externals/g4tools/include/tools/sg/GL_viewer
Vendored
-78
View File
@@ -1,78 +0,0 @@
// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.
#ifndef tools_sg_GL_viewer
#define tools_sg_GL_viewer
#include <tools/sg/viewer>
#include "GL_manager"
#include "GL_action"
namespace tools {
namespace sg {
class GL_viewer : public tools::sg::viewer {
TOOLS_HEADER(GL_viewer,tools::sg::GL_viewer,tools::sg::viewer)
public:
void render() {
if(!m_ww) return;
if(!m_wh) return;
m_gl_mgr.begin_render(0,0,m_ww,m_wh,
m_clear_color.r(),
m_clear_color.g(),
m_clear_color.b(),
m_clear_color.a());
GL_action action(m_gl_mgr,m_out,m_ww,m_wh);
action.state().m_use_gsto = m_use_gsto;
action.set_do_transparency(false);
action.set_have_to_do_transparency(false);
m_sg.render(action);
if(!action.end()) { //check that matrices stack are ok.
m_out << "tools::sg::GL_viewer : bad gl_action end." << std::endl;
} else {
if(action.have_to_do_transparency()) {
action.set_do_transparency(true);
m_sg.render(action);
if(!action.end()) { //check that matrices stack are ok.
m_out << "tools::sg::GL_viewer : bad gl_action end." << std::endl;
}
}
}
//after_render();
m_gl_mgr.end_render();
}
public:
GL_viewer(std::ostream& a_out,unsigned int a_width,unsigned int a_height)
:parent(a_out,a_width,a_height)
,m_gl_mgr(a_out)
{}
virtual ~GL_viewer(){
//WARNING : nodes may refer m_gl_mgr (to handle gstos/texs), then
// we have to delete them first.
m_sg.clear();
}
public:
GL_viewer(const GL_viewer& a_from)
:parent(a_from)
,m_gl_mgr(a_from.m_gl_mgr)
{}
GL_viewer& operator=(const GL_viewer& a_from){
parent::operator=(a_from);
m_gl_mgr = a_from.m_gl_mgr;
return *this;
}
protected:
GL_manager m_gl_mgr;
};
}}
#endif
source/externals/g4tools/include/tools/sg/base_tex
Vendored
+3 -3
View File
@@ -90,7 +90,7 @@ protected:
}
//a_out << "debug : tools::sg::tex_rect::update_sg :"
// << " this " << inlib::p2s(this)
// << " this " << tools::p2s(this)
// << std::endl;
// image must be power of two in width and height.
@@ -123,7 +123,7 @@ protected:
if(!img4.to_texture(expand.value(),pixel,m_img)){
a_out << "tools::sg::tex_rect::update_sg :"
<< " problem with inlib::tex_rect::to_texture."
<< " problem with tools::tex_rect::to_texture."
<< std::endl;
m_img.make_empty();
return;
@@ -132,7 +132,7 @@ protected:
} else {
if(!_img.to_texture(expand.value(),pixel,m_img)){
a_out << "tools::sg::tex_rect::update_sg :"
<< " problem with inlib::tex_rect::to_texture."
<< " problem with tools::tex_rect::to_texture."
<< std::endl;
m_img.make_empty();
return;
source/externals/g4tools/include/tools/sg/f2plot
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@
#ifndef tools_sg_f2plot
#define tools_sg_f2plot
// Connexion inlib/func to sg/plotter.
// Connexion tools/func to sg/plotter.
#include "plottables"
source/externals/g4tools/include/tools/sg/gl
Vendored
-110
View File
@@ -1,110 +0,0 @@
// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.
#ifndef tools_sg_gl
#define tools_sg_gl
#include "../OpenGL"
#include <tools/platform> //for APPLE TargetConditionals.h
#include <tools/img>
#include <ostream>
namespace tools {
namespace sg {
//namespace gl : no, problem with g4tools.
inline void gl_clear_errors() {
GLenum glerror = ::glGetError();
while(glerror!=GL_NO_ERROR) {
glerror = ::glGetError();
}
}
inline bool gl_dump_if_errors(std::ostream& a_out,const std::string& a_head) {
bool retval = false;
GLenum glerror = ::glGetError();
if(glerror!=GL_NO_ERROR) {
a_out << a_head
<< " we have gl errors :"
<< std::endl;
retval = true;
}
while(glerror!=GL_NO_ERROR) {
//#define GL_NO_ERROR 0
//#define GL_INVALID_ENUM 0x0500
//#define GL_INVALID_VALUE 0x0501
//#define GL_INVALID_OPERATION 0x0502
//#define GL_STACK_OVERFLOW 0x0503
//#define GL_STACK_UNDERFLOW 0x0504
//#define GL_OUT_OF_MEMORY 0x0505
//#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506
a_out << "0x" << std::hex << glerror << std::endl;
glerror = ::glGetError();
}
return retval;
}
inline void gl_dump_infos(std::ostream& a_out) {
std::string gl_version;
{const char* _sv = (const char*)::glGetString(GL_VERSION);
if(_sv) gl_version = _sv;}
std::string gl_vendor;
{const char* _sv = (const char*)::glGetString(GL_VENDOR);
if(_sv) gl_vendor = _sv;}
std::string gl_renderer;
{const char* _sv = (const char*)::glGetString(GL_RENDERER);
if(_sv) gl_renderer = _sv;}
std::string gl_extensions;
{const char* _sv = (const char*)::glGetString(GL_EXTENSIONS);
if(_sv) gl_extensions = _sv;}
GLint gl_texture_size;
::glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_texture_size);
//GLint gl_buffer_size;
//::glGetIntegerv(GL_BUFFER_SIZE, &gl_buffer_size);
a_out << "tools::sg::gl::dump_infos :" << std::endl;
a_out << " GL_VERSION " << gl_version << std::endl;
a_out << " GL_VENDOR " << gl_vendor << std::endl;
a_out << " GL_RENDERER " << gl_renderer << std::endl;
a_out << " GL_EXTENSIONS " << gl_extensions << std::endl;
a_out << " GL_MAX_TEXTURE_SIZE " << gl_texture_size << std::endl;
//a_out << " GL_BUFFER_SIZE " << gl_buffer_size << std::endl;
}
inline bool gl_tex_img(std::ostream& a_out,const tools::img_byte& a_img) {
if(a_img.bpp()==1) {
//to pass eiffel-tower.png
#if defined(ANDROID) || TARGET_OS_IPHONE
tools::img_byte res;
if(!a_img.bw2x(3,res)) {
a_out << "tools::sg::gl::tex_img : tools::img.bw2x() failed." << std::endl;
return false;
}
::glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,res.width(),res.height(),0,GL_RGB,GL_UNSIGNED_BYTE,res.buffer());
#else
::glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,a_img.width(),a_img.height(),0,GL_LUMINANCE,GL_UNSIGNED_BYTE,a_img.buffer());
#endif
} else if(a_img.bpp()==3) {
::glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,a_img.width(),a_img.height(),0,GL_RGB,GL_UNSIGNED_BYTE,a_img.buffer());
} else if(a_img.bpp()==4) {
::glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,a_img.width(),a_img.height(),0,GL_RGBA,GL_UNSIGNED_BYTE,a_img.buffer());
} else {
a_out << "tools::sg::gl::tex_img : img.bpp() " << a_img.bpp() << " not treated." << std::endl;
return false;
}
return true;
}
}}
#endif
source/externals/g4tools/include/tools/sg/gl2ps_action
Vendored
+67 -22
View File
@@ -163,6 +163,7 @@ public:
gl2ps_action(gl2ps_manager& a_mgr,std::ostream& a_out,unsigned int a_ww,unsigned int a_wh)
:parent(a_out,a_ww,a_wh)
,m_mgr(a_mgr)
,m_gl2ps_context(0)
,m_FILE(0)
,m_pv(get_me())
,m_light_color(colorf_white())
@@ -193,11 +194,14 @@ public:
m_model.set_identity();
m_normal_matrix.set_identity();
}
virtual ~gl2ps_action(){}
virtual ~gl2ps_action(){
close();
}
protected:
gl2ps_action(const gl2ps_action& a_from)
:parent(a_from)
,m_mgr(a_from.m_mgr)
,m_gl2ps_context(0)
,m_FILE(0)
,m_vp_mtx(a_from.m_vp_mtx)
@@ -255,12 +259,23 @@ protected:
}
public:
bool open(const std::string& a_name,int a_format = TOOLS_GL2PS_EPS) {
if(m_FILE) return false;
close();
m_gl2ps_context = ::tools_gl2psCreateContext();
if(!m_gl2ps_context) {
m_out << "tools::sg::gl2ps_action::open :"
<< " can't create gl2ps context."
<< std::endl;
return false;
}
m_FILE = ::fopen(a_name.c_str(),"w");
if(!m_FILE) {
m_out << "tools::sg::gl2ps_action::open :"
<< " can't open file " << a_name << "."
<< std::endl;
::tools_gl2psDeleteContext(m_gl2ps_context);
m_gl2ps_context = 0;
return false;
}
@@ -279,12 +294,21 @@ public:
vp[3] = m_wh;
int bufsize = 0;
::tools_gl2psBeginPage("","tools_sg_write_gl2ps",
if(::tools_gl2psBeginPage(m_gl2ps_context,"","tools_sg_write_gl2ps",
vp,a_format,sort,options,
TOOLS_GL_RGBA,0, NULL,0,0,0,bufsize,
m_FILE,a_name.c_str());
::tools_gl2psSetBackgroundColor(m_back[0],m_back[1],m_back[2]);
m_FILE,a_name.c_str())==TOOLS_GL2PS_ERROR) {
m_out << "tools::sg::gl2ps_action::open :"
<< " tools_gl2psBeginPage() failed."
<< std::endl;
::fclose(m_FILE);
m_FILE = 0;
::tools_gl2psDeleteContext(m_gl2ps_context);
m_gl2ps_context = 0;
return false;
}
::tools_gl2psSetBackgroundColor(m_gl2ps_context,m_back[0],m_back[1],m_back[2]);
m_vp_mtx.set_identity();
m_vp_mtx.mul_translate(float(m_ww)/2,float(m_wh)/2,0);
@@ -294,10 +318,19 @@ public:
}
bool close() {
if(!m_FILE) return false;
::tools_gl2psEndPage();
::fclose(m_FILE);
m_FILE = 0;
tools_GLint _status = 0;
if(m_gl2ps_context) {
_status = ::tools_gl2psEndPage(m_gl2ps_context);
}
if(m_FILE) {
::fclose(m_FILE);
m_FILE = 0;
}
if(m_gl2ps_context) {
::tools_gl2psDeleteContext(m_gl2ps_context);
m_gl2ps_context = 0;
}
if (_status == TOOLS_GL2PS_OVERFLOW) return false;
return true;
}
void set_background(float a_r,float a_g,float a_b) {
@@ -349,6 +382,8 @@ protected:
return m_this.project_point(a_x,a_y,a_z,a_w);
}
virtual bool add_point(float a_x,float a_y,float a_z,float) {
if(!m_this.m_gl2ps_context) return false;
float r = m_this.m_color[0];
float g = m_this.m_color[1];
float b = m_this.m_color[2];
@@ -369,13 +404,14 @@ protected:
m_this.m_vp_mtx.mul_3f(a_x,a_y,a_z);
m_this.set_vtx(vertices,0, a_x,a_y,a_z, r,g,b,a);
::tools_gl2psAddPolyPrimitive(_GL2PS_POINT(),1,vertices,offset,ofactor,ounits,pattern,factor,sz,linecap,linejoin,boundary);
::tools_gl2psAddPolyPrimitive(m_this.m_gl2ps_context,_GL2PS_POINT(),1,vertices,offset,ofactor,ounits,pattern,factor,sz,linecap,linejoin,boundary);
return true;
}
virtual bool add_point(float a_x,float a_y,float a_z,float,
float a_r,float a_g,float a_b,float a_a) {
if(!m_this.m_gl2ps_context) return false;
tools_GLint offset = 0;
tools_GLfloat ofactor = 0; //
tools_GLfloat ounits = 0; //
@@ -392,13 +428,15 @@ protected:
m_this.set_vtx(vertices,0, a_x,a_y,a_z, a_r,a_g,a_b,a_a);
//::tools_gl2psAddPolyPrimitive(_GL2PS_POINT(),1,vertices,0,pattern,factor,sz,0);
::tools_gl2psAddPolyPrimitive(_GL2PS_POINT(),1,vertices,offset,ofactor,ounits,pattern,factor,sz,linecap,linejoin,boundary);
//::tools_gl2psAddPolyPrimitive(m_this.m_gl2ps_context,_GL2PS_POINT(),1,vertices,0,pattern,factor,sz,0);
::tools_gl2psAddPolyPrimitive(m_this.m_gl2ps_context,_GL2PS_POINT(),1,vertices,offset,ofactor,ounits,pattern,factor,sz,linecap,linejoin,boundary);
return true;
}
virtual bool add_line(float a_bx,float a_by,float a_bz,float,
float a_ex,float a_ey,float a_ez,float) {
if(!m_this.m_gl2ps_context) return false;
float r = m_this.m_color[0];
float g = m_this.m_color[1];
float b = m_this.m_color[2];
@@ -422,8 +460,8 @@ protected:
m_this.set_vtx(vertices,0, a_bx,a_by,a_bz, r,g,b,a);
m_this.set_vtx(vertices,1, a_ex,a_ey,a_ez, r,g,b,a);
//::tools_gl2psAddPolyPrimitive(_GL2PS_LINE(),2,vertices,0,pattern,factor,lwidth,0);
::tools_gl2psAddPolyPrimitive(_GL2PS_LINE(),2,vertices,offset,ofactor,ounits,pattern,factor,lwidth,linecap,linejoin,boundary);
//::tools_gl2psAddPolyPrimitive(m_this.m_gl2ps_context,_GL2PS_LINE(),2,vertices,0,pattern,factor,lwidth,0);
::tools_gl2psAddPolyPrimitive(m_this.m_gl2ps_context,_GL2PS_LINE(),2,vertices,offset,ofactor,ounits,pattern,factor,lwidth,linecap,linejoin,boundary);
return true;
}
@@ -432,6 +470,7 @@ protected:
float a_br,float a_bg,float a_bb,float a_ba,
float a_ex,float a_ey,float a_ez,float,
float a_er,float a_eg,float a_eb,float a_ea){
if(!m_this.m_gl2ps_context) return false;
tools_GLint offset = 0;
tools_GLfloat ofactor = 0; //
@@ -451,8 +490,8 @@ protected:
m_this.set_vtx(vertices,0, a_bx,a_by,a_bz, a_br,a_bg,a_bb,a_ba);
m_this.set_vtx(vertices,1, a_ex,a_ey,a_ez, a_er,a_eg,a_eb,a_ea);
//tools_gl2psAddPolyPrimitive(_GL2PS_LINE(),2,vertices,0,pattern,factor,lwidth,0);
::tools_gl2psAddPolyPrimitive(_GL2PS_LINE(),2,vertices,offset,ofactor,ounits,pattern,factor,lwidth,linecap,linejoin,boundary);
//tools_gl2psAddPolyPrimitive(m_this.m_gl2ps_context,_GL2PS_LINE(),2,vertices,0,pattern,factor,lwidth,0);
::tools_gl2psAddPolyPrimitive(m_this.m_gl2ps_context,_GL2PS_LINE(),2,vertices,offset,ofactor,ounits,pattern,factor,lwidth,linecap,linejoin,boundary);
return true;
}
@@ -460,6 +499,8 @@ protected:
virtual bool add_triangle(float a_p1x,float a_p1y,float a_p1z,float,
float a_p2x,float a_p2y,float a_p2z,float,
float a_p3x,float a_p3y,float a_p3z,float){
if(!m_this.m_gl2ps_context) return false;
float r = m_this.m_color[0];
float g = m_this.m_color[1];
float b = m_this.m_color[2];
@@ -485,8 +526,8 @@ protected:
m_this.set_vtx(vertices,1, a_p2x,a_p2y,a_p2z, r,g,b,a);
m_this.set_vtx(vertices,2, a_p3x,a_p3y,a_p3z, r,g,b,a);
//tools_gl2psAddPolyPrimitive(_GL2PS_TRIANGLE(),3,vertices,0,pattern,factor,lwidth,0);
::tools_gl2psAddPolyPrimitive(_GL2PS_TRIANGLE(),3,vertices,offset,ofactor,ounits,pattern,factor,lwidth,linecap,linejoin,boundary);
//tools_gl2psAddPolyPrimitive(m_this.m_gl2ps_context,_GL2PS_TRIANGLE(),3,vertices,0,pattern,factor,lwidth,0);
::tools_gl2psAddPolyPrimitive(m_this.m_gl2ps_context,_GL2PS_TRIANGLE(),3,vertices,offset,ofactor,ounits,pattern,factor,lwidth,linecap,linejoin,boundary);
return true;
}
@@ -499,6 +540,8 @@ protected:
float a_p3x,float a_p3y,float a_p3z,float,
float a_r3,float a_g3,float a_b3,float a_a3){
if(!m_this.m_gl2ps_context) return false;
tools_GLint offset = 0;
tools_GLfloat ofactor = 0; //
tools_GLfloat ounits = 0; //
@@ -519,8 +562,8 @@ protected:
m_this.set_vtx(vertices,1, a_p2x,a_p2y,a_p2z, a_r2,a_g2,a_b2,a_a2);
m_this.set_vtx(vertices,2, a_p3x,a_p3y,a_p3z, a_r3,a_g3,a_b3,a_a3);
//tools_gl2psAddPolyPrimitive(_GL2PS_TRIANGLE(),3,vertices,0,pattern,factor,lwidth,0);
::tools_gl2psAddPolyPrimitive(_GL2PS_TRIANGLE(),3,vertices,offset,ofactor,ounits,pattern,factor,lwidth,linecap,linejoin,boundary);
//tools_gl2psAddPolyPrimitive(m_this.m_gl2ps_context,_GL2PS_TRIANGLE(),3,vertices,0,pattern,factor,lwidth,0);
::tools_gl2psAddPolyPrimitive(m_this.m_gl2ps_context,_GL2PS_TRIANGLE(),3,vertices,offset,ofactor,ounits,pattern,factor,lwidth,linecap,linejoin,boundary);
return true;
}
@@ -616,6 +659,8 @@ protected:
protected:
gl2ps_manager& m_mgr;
tools_GL2PScontext* m_gl2ps_context;
FILE* m_FILE;
float m_back[3];
mat4f m_vp_mtx;
source/externals/g4tools/include/tools/sg/group
Vendored
+1 -1
View File
@@ -235,7 +235,7 @@ public:
void clear() {safe_reverse_clear<node>(m_children);}
void raw_clear() { //used for sg coming from exlib/rroot/vis_volume.
tools::raw_clear<node>(m_children); //inlib:: is needed.
tools::raw_clear<node>(m_children); //tools:: is needed.
}
//void children_clear() {m_children.clear();} //warning : nodes are not deleted. Used in [hep_]cone_anim.
source/externals/g4tools/include/tools/sg/h2plot
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@
#ifndef tools_sg_h2plot
#define tools_sg_h2plot
// Connexion inlib/histo to sg/plotter.
// Connexion tools/histo to sg/plotter.
// Inheritance :
#include "plottables"
source/externals/g4tools/include/tools/sg/infos_box
Vendored
+3 -3
View File
@@ -323,17 +323,17 @@ public:
/// middle spaces //////////////////////////////////////////
////////////////////////////////////////////////////////////
base_text* mtext = 0;
{std::string s(num_spaces,' ');
{std::string _s(num_spaces,' ');
if(font==font_hershey()) {
text_hershey* text = new text_hershey;
mtext = text;
text->strings.add(s);
text->strings.add(_s);
text->hjust = left;
} else {
base_freetype* text = base_freetype::create(m_ttf);
//TTNODE* text = new TTNODE;
mtext = text;
text->strings.add(s);
text->strings.add(_s);
text->hjust = left;
text->font = font;
text->modeling = font_modeling;
source/externals/g4tools/include/tools/sg/node
Vendored
+1 -1
View File
@@ -203,7 +203,7 @@ protected:
return false;
}
} /*else {
a_action.out() << "debug : inlib::node::read_fields :"
a_action.out() << "debug : tools::node::read_fields :"
<< " for node class " << s_cls()
<< " : field desc class " << fdesc.cls()
<< " : field desc offset " << fdesc.offset()
source/externals/g4tools/include/tools/sg/path
Vendored
+5 -5
View File
@@ -62,14 +62,14 @@ inline CONTAINER* container_container(const path_t& a_path) {
inline void dump(std::ostream& a_out,const path_t& a_path) {
a_out << "tools::sg::dump : path size " << a_path.size() << std::endl;
std::string s;
std::string _s;
path_t::const_iterator it;
for(it=a_path.begin();it!=a_path.end();++it){
if(!p2s(*it,s)) {}
a_out << " " << s << " " << (*it)->s_cls();
if(!p2s(*it,_s)) {}
a_out << " " << _s << " " << (*it)->s_cls();
if(noderef* _ref = safe_cast<node,noderef>(*(*it))) {
if(!p2s(&(_ref->node()),s)) {}
a_out << ", " << s << " " << _ref->node().s_cls();
if(!p2s(&(_ref->node()),_s)) {}
a_out << ", " << _s << " " << _ref->node().s_cls();
}
a_out << std::endl;
}
source/externals/g4tools/include/tools/sg/plotter
Vendored
+27 -27
View File
@@ -1866,7 +1866,7 @@ public: //public
float XMGR = right_margin;
float wData = XSIZ-XMGL-XMGR;
if(XSIZ==0.0F) {
//SoDebugError::postInfo("inlib::sg;:plotter::data_frame_2_vp","XSIZ is 0");
//SoDebugError::postInfo("tools::sg;:plotter::data_frame_2_vp","XSIZ is 0");
return false;
}
a_vp[0] = (wData*a_pos[0] + XMGL)/XSIZ;}
@@ -1876,7 +1876,7 @@ public: //public
float YMGU = top_margin;
float hData = YSIZ-YMGL-YMGU;
if(YSIZ==0.0F) {
//SoDebugError::postInfo("inlib::sg;:plotter::data_frame_2_vp","YSIZ is 0");
//SoDebugError::postInfo("tools::sg;:plotter::data_frame_2_vp","YSIZ is 0");
return false;
}
a_vp[1] = (hData*a_pos[1] + YMGL)/YSIZ;}
@@ -1886,7 +1886,7 @@ public: //public
float ZMGU = up_margin;
float dData = ZSIZ-ZMGD-ZMGU;
if(ZSIZ==0.0F) {
//SoDebugError::postInfo("inlib::sg;:plotter::data_frame_2_vp","ZSIZ is 0");
//SoDebugError::postInfo("tools::sg;:plotter::data_frame_2_vp","ZSIZ is 0");
return false;
}
a_vp[2] = (dData*a_pos[2] + ZMGD)/ZSIZ;}
@@ -1903,7 +1903,7 @@ public: //public
float XMGR = right_margin;
float wData = XSIZ-XMGL-XMGR;
if(wData==0.0F) {
//SoDebugError::postInfo("inlib::sg;:plotter::vp_2_data_frame","wData is 0");
//SoDebugError::postInfo("tools::sg;:plotter::vp_2_data_frame","wData is 0");
return false;
}
a_pos[0] = (a_vp[0]*XSIZ - XMGL)/wData;}
@@ -1913,7 +1913,7 @@ public: //public
float YMGU = top_margin;
float hData = YSIZ-YMGL-YMGU;
if(hData==0.0F) {
//SoDebugError::postInfo("inlib::sg;:plotter::vp_2_data_frame","hData is 0");
//SoDebugError::postInfo("tools::sg;:plotter::vp_2_data_frame","hData is 0");
return false;
}
a_pos[1] = (a_vp[1]*YSIZ - YMGL)/hData;}
@@ -1923,7 +1923,7 @@ public: //public
float ZMGU = up_margin;
float dData = ZSIZ-ZMGD-ZMGU;
if(dData==0.0F) {
//SoDebugError::postInfo("inlib::sg;:plotter::vp_2_data_frame","dData is 0");
//SoDebugError::postInfo("tools::sg;:plotter::vp_2_data_frame","dData is 0");
return false;
}
a_pos[2] = (a_vp[2]*ZSIZ - ZMGD)/dData;}
@@ -1977,19 +1977,19 @@ public: //public
float mx = m_x_axis.maximum_value;
if(mx==mn) {
//SoDebugError::postInfo
// ("inlib::sg;:plotter::axis_2_data_frame","x : mn (%g) == mx (%g)",mn,mx);
// ("tools::sg;:plotter::axis_2_data_frame","x : mn (%g) == mx (%g)",mn,mx);
return false;
}
bool lg = m_x_axis.is_log;
if(lg) {
if(mn<=0) {
//SoDebugError::postInfo
// ("inlib::sg;:plotter::axis_2_data_frame","x log but mn (%g) <=0",mn);
// ("tools::sg;:plotter::axis_2_data_frame","x log but mn (%g) <=0",mn);
return false;
}
if(mx<=0) {
//SoDebugError::postInfo
// ("inlib::sg;:plotter::axis_2_data_frame","x log but mx (%g) <=0",mx);
// ("tools::sg;:plotter::axis_2_data_frame","x log but mx (%g) <=0",mx);
return false;
}
mn = flog10(mn);
@@ -2001,19 +2001,19 @@ public: //public
float mx = m_y_axis.maximum_value;
if(mx==mn) {
//SoDebugError::postInfo
// ("inlib::sg;:plotter::axis_2_data_frame","y : mn (%g) == mx (%g)",mn,mx);
// ("tools::sg;:plotter::axis_2_data_frame","y : mn (%g) == mx (%g)",mn,mx);
return false;
}
bool lg = m_y_axis.is_log;
if(lg) {
if(mn<=0) {
//SoDebugError::postInfo
// ("inlib::sg;:plotter::axis_2_data_frame","y log but mn (%g) <=0",mn);
// ("tools::sg;:plotter::axis_2_data_frame","y log but mn (%g) <=0",mn);
return false;
}
if(mx<=0) {
//SoDebugError::postInfo
// ("inlib::sg;:plotter::axis_2_data_frame","y log but mx (%g) <=0",mx);
// ("tools::sg;:plotter::axis_2_data_frame","y log but mx (%g) <=0",mx);
return false;
}
mn = flog10(mn);
@@ -2025,19 +2025,19 @@ public: //public
float mx = m_z_axis.maximum_value;
if(mx==mn) {
//SoDebugError::postInfo
// ("inlib::sg;:plotter::axis_2_data_frame","z : mn (%g) == mx (%g)",mn,mx);
// ("tools::sg;:plotter::axis_2_data_frame","z : mn (%g) == mx (%g)",mn,mx);
return false;
}
bool lg = m_z_axis.is_log;
if(lg) {
if(mn<=0) {
//SoDebugError::postInfo
// ("inlib::sg;:plotter::axis_2_data_frame","z log but mn (%g) <=0",mn);
// ("tools::sg;:plotter::axis_2_data_frame","z log but mn (%g) <=0",mn);
return false;
}
if(mx<=0) {
//SoDebugError::postInfo
// ("inlib::sg;:plotter::axis_2_data_frame","z log but mx (%g) <=0",mx);
// ("tools::sg;:plotter::axis_2_data_frame","z log but mx (%g) <=0",mx);
return false;
}
mn = flog10(mn);
@@ -2277,8 +2277,8 @@ protected:
rotf r3(vec3f(1,0,0),tau * fdeg2rad());
rotf r = r1*r2*r3;
mat4f m;
r.value(m);
mat4f _m;
r.value(_m);
float xmn = -0.5F*wData;
float ymn = -0.5F*hData;
@@ -2291,30 +2291,30 @@ protected:
float x,y,z;
// zmn face :
{x = xmn;y = ymn;z = zmn;
m.mul_3f(x,y,z);
_m.mul_3f(x,y,z);
_box.extend_by(x,y,z);}
{x = xmx;y = ymn;z = zmn;
m.mul_3f(x,y,z);
_m.mul_3f(x,y,z);
_box.extend_by(x,y,z);}
{x = xmx;y = ymx;z = zmn;
m.mul_3f(x,y,z);
_m.mul_3f(x,y,z);
_box.extend_by(x,y,z);}
{x = xmn;y = ymx;z = zmn;
m.mul_3f(x,y,z);
_m.mul_3f(x,y,z);
_box.extend_by(x,y,z);}
// zmx face :
{x = xmn;y = ymn;z = zmx;
m.mul_3f(x,y,z);
_m.mul_3f(x,y,z);
_box.extend_by(x,y,z);}
{x = xmx;y = ymn;z = zmx;
m.mul_3f(x,y,z);
_m.mul_3f(x,y,z);
_box.extend_by(x,y,z);}
{x = xmx;y = ymx;z = zmx;
m.mul_3f(x,y,z);
_m.mul_3f(x,y,z);
_box.extend_by(x,y,z);}
{x = xmn;y = ymx;z = zmx;
m.mul_3f(x,y,z);
_m.mul_3f(x,y,z);
_box.extend_by(x,y,z);}
float xfac = _box.mx()[0]-_box.mn()[0];
@@ -2574,7 +2574,7 @@ public:
////////////////////////////////////
//if(verbose) {
// SoDebugError::postInfo("inlib::sg;:plotter::updateChildren",
// SoDebugError::postInfo("tools::sg;:plotter::updateChildren",
// "%lu : XY : update bins",(unsigned long)this);
//}
@@ -7439,7 +7439,7 @@ protected: //rep
const std::vector<rep_bin1D>& a_bins,
const rep_box& a_box_x,const rep_box& a_box_y,float a_zz,
bool a_bar_chart){
//printf("debug : inlib::sg;:plotter::repHatch1D_xy : zz %g barchart %d sw %g\n",a_zz,aBarChart,a_style.stripWidth.getValue());
//printf("debug : tools::sg;:plotter::repHatch1D_xy : zz %g barchart %d sw %g\n",a_zz,aBarChart,a_style.stripWidth.getValue());
separator* _sep = new separator;
source/externals/g4tools/include/tools/sg/senum
Vendored
+3 -3
View File
@@ -329,9 +329,9 @@ namespace tools {
namespace sg {
inline bool scolor(const colorf& a_col,std::string& a_s){
char s[256];
snpf(s,sizeof(s),"%g %g %g",a_col[0],a_col[1],a_col[2]);
a_s = s;
char _s[256];
snpf(_s,sizeof(_s),"%g %g %g",a_col[0],a_col[1],a_col[2]);
a_s = _s;
return true;
}
source/externals/g4tools/include/tools/sg/style_colormap
Vendored
+9 -9
View File
@@ -564,17 +564,17 @@ inline bool find_color(const cmaps_t& a_cmaps,const std::string& a_s,colorf& a_c
// 1 3 5
unsigned long rr,gg,bb;
{std::string s("0x");
s += a_s.substr(1,2);
if(!to_ulong(s,rr)) return false;}
{std::string _s("0x");
_s += a_s.substr(1,2);
if(!to_ulong(_s,rr)) return false;}
{std::string s("0x");
s += a_s.substr(3,2);
if(!to_ulong(s,gg)) return false;}
{std::string _s("0x");
_s += a_s.substr(3,2);
if(!to_ulong(_s,gg)) return false;}
{std::string s("0x");
s += a_s.substr(5,2);
if(!to_ulong(s,bb)) return false;}
{std::string _s("0x");
_s += a_s.substr(5,2);
if(!to_ulong(_s,bb)) return false;}
a_col = colorf(((float)rr)/255,((float)gg)/255,((float)bb)/255);
return true;
source/externals/g4tools/include/tools/sg/style_parser
Vendored
+86 -86
View File
@@ -357,123 +357,123 @@ translation %g %g %g"
,m_translation[0],m_translation[1],m_translation[2]);
std::string lf("\n");
std::string s(ss);
std::string _s(ss);
s += lf;
s += "smoothing ";
s += (m_smoothing?"true":"false");
_s += lf;
_s += "smoothing ";
_s += (m_smoothing?"true":"false");
s += lf;
s += "hinting ";
s += (m_hinting?"true":"false");
_s += lf;
_s += "hinting ";
_s += (m_hinting?"true":"false");
s += lf;
s += "enforced ";
s += (m_enforced?"true":"false");
_s += lf;
_s += "enforced ";
_s += (m_enforced?"true":"false");
s += lf;
s += "visible ";
s += (m_visible?"true":"false");
_s += lf;
_s += "visible ";
_s += (m_visible?"true":"false");
s += lf;
s += "editable ";
s += (m_editable?"true":"false");
_s += lf;
_s += "editable ";
_s += (m_editable?"true":"false");
s += lf;
s += "automated ";
s += (m_automated?"true":"false");
_s += lf;
_s += "automated ";
_s += (m_automated?"true":"false");
s += lf;
s += "pickable ";
s += (m_pickable?"true":"false");
_s += lf;
_s += "pickable ";
_s += (m_pickable?"true":"false");
s += lf;
s += "marker_style ";
s += smarker_style(m_marker_style);
_s += lf;
_s += "marker_style ";
_s += smarker_style(m_marker_style);
s += lf;
s += "area_style ";
s += sarea_style(m_area_style);
_s += lf;
_s += "area_style ";
_s += sarea_style(m_area_style);
s += lf;
s += "modeling ";
s += m_modeling;
_s += lf;
_s += "modeling ";
_s += m_modeling;
s += lf;
s += "coloring ";
s += m_coloring;
_s += lf;
_s += "coloring ";
_s += m_coloring;
s += lf;
s += "title ";
s += m_title;
_s += lf;
_s += "title ";
_s += m_title;
s += lf;
s += "light_model ";
s += m_light_model;
_s += lf;
_s += "light_model ";
_s += m_light_model;
s += lf;
s += "tick_modeling ";
s += m_tick_modeling;
_s += lf;
_s += "tick_modeling ";
_s += m_tick_modeling;
s += lf;
s += "encoding ";
s += m_encoding;
_s += lf;
_s += "encoding ";
_s += m_encoding;
s += lf;
s += "cut ";
s += m_cut;
_s += lf;
_s += "cut ";
_s += m_cut;
s += lf;
s += "painting ";
s += spainting_policy(m_painting);
_s += lf;
_s += "painting ";
_s += spainting_policy(m_painting);
s += lf;
s += "hatching ";
s += shatching_policy(m_hatching);
_s += lf;
_s += "hatching ";
_s += shatching_policy(m_hatching);
s += lf;
s += "projection ";
s += sprojection_type(m_projection);
_s += lf;
_s += "projection ";
_s += sprojection_type(m_projection);
s += lf;
s += "font ";
s += m_font;
_s += lf;
_s += "font ";
_s += m_font;
if(m_font_modeling==font_outline) {
s += lf;
s += "font_modeling ";
s += s_font_outline();
_s += lf;
_s += "font_modeling ";
_s += s_font_outline();
} else if(m_font_modeling==font_filled) {
s += lf;
s += "font_modeling ";
s += s_font_filled();
_s += lf;
_s += "font_modeling ";
_s += s_font_filled();
} else if(m_font_modeling==font_pixmap) {
s += lf;
s += "font_modeling ";
s += s_font_pixmap();
_s += lf;
_s += "font_modeling ";
_s += s_font_pixmap();
}
s += lf;
s += "options ";
s += m_options;
_s += lf;
_s += "options ";
_s += m_options;
s += lf;
s += "color_mapping ";
s += m_color_mapping;
_s += lf;
_s += "color_mapping ";
_s += m_color_mapping;
s += lf;
s += "front_face ";
s += (m_front_face==winding_ccw?"ccw":"cw");
_s += lf;
_s += "front_face ";
_s += (m_front_face==winding_ccw?"ccw":"cw");
s += lf;
s += "hjust ";
s += shjust(m_hjust);
_s += lf;
_s += "hjust ";
_s += shjust(m_hjust);
s += lf;
s += "vjust ";
s += svjust(m_vjust);
_s += lf;
_s += "vjust ";
_s += svjust(m_vjust);
return s;
return _s;
}
void color(const colorf& a_v){m_color = a_v;}
source/externals/g4tools/include/tools/sg/text
Vendored
+29 -17
View File
@@ -317,9 +317,6 @@ public:
matrix* tsf = new matrix;
m_sep.add(tsf);
float fw = width * wmargin_factor;
float fh = height * hmargin_factor;
//sf<float> zfront ?
float zz = back_visible.value()?0.01f:0;
@@ -364,9 +361,9 @@ public:
if(hjust==center) {
xtrans = 0;
} else if(hjust==left) {
xtrans = -fw*0.5f+bxw*0.5f;
xtrans = bxw*0.5f;
} else if(hjust==right) {
xtrans = fw*0.5f-bxw*0.5f;
xtrans = -bxw*0.5f;
}
float bxh = mx_y-mn_y;
@@ -374,20 +371,21 @@ public:
if(vjust==middle) {
ytrans = 0;
} else if(vjust==bottom) {
ytrans = -fh*0.5f+bxh*0.5f;
ytrans = bxh*0.5f;
} else if(vjust==top) {
ytrans = fh*0.5f-bxh*0.5f;
ytrans = -bxh*0.5f;
}
float xx = -(mn_x+mx_x)*0.5F+xtrans;
float yy = -(mn_y+mx_y)*0.5F+ytrans;
tsf->set_translate(xx,yy,zz);
return;
}
if(enforce_front_width) {
float fh = height * hmargin_factor;
float th = fh;
float mn_x,mn_y,mn_z;
float mx_x,mx_y,mx_z;
@@ -406,9 +404,9 @@ public:
if(hjust==center) {
xtrans = 0;
} else if(hjust==left) {
xtrans = -fw*0.5f+bxw*0.5f;
xtrans = bxw*0.5f;
} else if(hjust==right) {
xtrans = fw*0.5f-bxw*0.5f;
xtrans = -bxw*0.5f;
}
float bxh = mx_y-mn_y;
@@ -416,9 +414,9 @@ public:
if(vjust==middle) {
ytrans = 0;
} else if(vjust==bottom) {
ytrans = -fh*0.5f+bxh*0.5f;
ytrans = bxh*0.5f;
} else if(vjust==top) {
ytrans = fh*0.5f-bxw*0.5f;
ytrans = -bxh*0.5f;
}
float xx = -(mn_x+mx_x)*0.5F+xtrans;
@@ -426,15 +424,16 @@ public:
tsf->set_translate(xx,yy,zz);
m_base_text->height = bxh; //=th?
return;
}
//various automatic text height strategies :
float fw = width * wmargin_factor;
float fh = height * hmargin_factor;
if(confine) {
// code common to freetype and hershey :
// try to adjust text within fw x fh (by attempting to be smart !).
// the below assumes that text bounds are linear according
// "text height".
@@ -488,7 +487,7 @@ public:
} else if(vjust==bottom) {
ytrans = -fh*0.5f+bxh*0.5f;
} else if(vjust==top) {
ytrans = fh*0.5f-bxw*0.5f;
ytrans = fh*0.5f-bxh*0.5f;
}
float xx = -(mn_x+mx_x)*0.5F+xtrans;
@@ -498,7 +497,7 @@ public:
}
} else {
} else {
// we arrange yy so that two aside texts
// with same height will have their text base lines aligned.
@@ -548,7 +547,7 @@ public:
} else if(vjust==bottom) {
ytrans = -fh*0.5f+bxh*0.5f;
} else if(vjust==top) {
ytrans = fh*0.5f-bxw*0.5f;
ytrans = fh*0.5f-bxh*0.5f;
}
*/
float xx = -(mn_x+mx_x)*0.5F+xtrans;
@@ -565,6 +564,19 @@ public:
}
}
void map_back_area_to_text() {
if(!m_base_text) return;
float mn_x,mn_y,mn_z;
float mx_x,mx_y,mx_z;
m_base_text->get_bounds(front_height,mn_x,mn_y,mn_z,mx_x,mx_y,mx_z);
float bxw = mx_x-mn_x;
float bxh = mx_y-mn_y;
parent::width = bxw/wmargin_factor;
parent::height = bxh/hmargin_factor;
}
protected:
separator m_sep;
base_text* m_base_text;
source/externals/g4tools/include/tools/sg/text_freetype
Vendored
-2197
View File
File diff suppressed because it is too large Load Diff
source/externals/g4tools/include/tools/sg/text_freetype_marker
Vendored
-264
View File
@@ -1,264 +0,0 @@
// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.
#ifndef tools_sg_text_freetype_marker
#define tools_sg_text_freetype_marker
#include "text_freetype"
namespace tools {
namespace sg {
class text_freetype_marker : public text_freetype {
TOOLS_NODE(text_freetype_marker,tools::sg::text_freetype_marker,text_freetype)
public:
virtual bool draw_in_frame_buffer() const {return true;}
virtual void render(tools::sg::render_action& a_action) {
{bool _color_touched = color_touched(a_action.state());
bool _char_height_touched = char_height_touched(a_action.state());
if(touched()||_color_touched||_char_height_touched) {
update_sg(a_action.out(),font.touched(),a_action.state());
reset_touched();
}}
const tools::sg::state& state = a_action.state();
a_action.set_lighting(false); //Same logic as Inventor SoLightModel.model = BASE_COLOR.
a_action.set_depth_test(false);
if(m_wndg==wndg_ccw) a_action.set_winding(tools::sg::winding_ccw);
else if(m_wndg==wndg_cw) a_action.set_winding(tools::sg::winding_cw);
float x,y,z;
a_action.projected_origin(x,y,z);
float zz = 0;
a_action.load_matrices_to_identity();
{tools::mat4f _mtx;
_mtx.set_translate(x,y,zz);
if(!m_bitmaps.size()) {
if(state.m_ww) _mtx.mul_scale(float(state.m_wh)/float(state.m_ww),1,1);
}
a_action.load_model_matrix(_mtx);}
///////////////////////////////////////////////////////////
/// lines /////////////////////////////////////////////////
///////////////////////////////////////////////////////////
{tools_vforcit(line_t,m_lines,it) {
const line_t& item = *it;
size_t pos = item.first;
size_t num = item.second;
if(!num) continue;
const float* data = tools::vec_data<float>(m_xys)+pos;
a_action.draw_vertex_array_xy(tools::gl::line_strip(),num*2,data);
}}
///////////////////////////////////////////////////////////
/// triangles /////////////////////////////////////////////
///////////////////////////////////////////////////////////
{tools_vforcit(gl_triangle_t,m_triangles,it) {
const std::pair<GLUenum,triangle_t>& item = *it;
size_t pos = item.second.first;
size_t num = item.second.second;
if(!num) continue;
//a_out << "tools::sg::text_freetype_marker::render :"
// << " num points " << num
// << std::endl;
const float* data = tools::vec_data<float>(m_xys)+pos;
a_action.draw_vertex_array_xy((*it).first,num*2,data);
}}
///////////////////////////////////////////////////////////
/// bitmap ////////////////////////////////////////////////
///////////////////////////////////////////////////////////
if(m_bitmaps.size()) {
#if defined(ANDROID) /*|| TARGET_OS_IPHONE*/
// we do not have transparent texture here (see also gl/tex_img() that does img/4-bytes => img/3-bytes) :
{tools::sg::state& _state = a_action.state();
tools::colorf old_color = _state.m_color;
_state.m_color = tools::colorf_white();
a_action.color4f(_state.m_color);
m_bitmaps.render(a_action);
_state.m_color = old_color;
a_action.color4f(_state.m_color);}
#else
m_bitmaps.render(a_action);
#endif
}
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
a_action.load_matrices_from_state();
a_action.set_depth_test(state.m_GL_DEPTH_TEST);
a_action.set_lighting(state.m_GL_LIGHTING);
a_action.set_winding(state.m_winding);
}
virtual void pick(tools::sg::pick_action& a_action) {
const tools::sg::state& state = a_action.state();
{bool _char_height_touched = char_height_touched(a_action.state());
if(touched()||_char_height_touched) {
update_sg(a_action.out(),font.touched(),a_action.state());
reset_touched();
}}
float x,y,z;
a_action.projected_origin(x,y,z);
float zz = 0;
a_action.set_matrices_to_identity();
a_action.model_matrix().set_translate(x,y,zz);
if(!m_bitmaps.size()) {
if(state.m_ww) a_action.model_matrix().mul_scale(float(state.m_wh)/float(state.m_ww),1,1);
}
///////////////////////////////////////////////////////////
/// lines /////////////////////////////////////////////////
///////////////////////////////////////////////////////////
{tools_vforcit(line_t,m_lines,it) {
const line_t& item = *it;
size_t pos = item.first;
size_t num = item.second;
if(!num) continue;
const float* data = tools::vec_data<float>(m_xys)+pos;
float* vp = _trans2(num,data,x,y);
if(!vp) continue;
if(a_action.add__line_strip_xy(*this,2*num,vp,true)) {
delete [] vp;
a_action.set_matrices_from_state();
return;
}
delete [] vp;
}}
///////////////////////////////////////////////////////////
/// triangles /////////////////////////////////////////////
///////////////////////////////////////////////////////////
{tools_vforcit(gl_triangle_t,m_triangles,it) {
const std::pair<GLUenum,triangle_t>& item = *it;
size_t pos = item.second.first;
size_t num = item.second.second;
if(!num) continue;
const float* data = tools::vec_data<float>(m_xys)+pos;
float* vp = _trans2(num,data,x,y);
if(!vp) continue;
if(a_action.add__primitive_xy(*this,item.first,2*num,vp,true)){
delete [] vp;
a_action.set_matrices_from_state();
return;
}
delete [] vp;
}}
///////////////////////////////////////////////////////////
/// bitmap ////////////////////////////////////////////////
///////////////////////////////////////////////////////////
if(m_bitmaps.size()) {
m_bitmaps.pick(a_action);
}
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
a_action.set_matrices_from_state();
}
virtual void bbox(tools::sg::bbox_action& a_action) {
{bool _char_height_touched = char_height_touched(a_action.state());
if(touched()||_char_height_touched) {
update_sg(a_action.out(),font.touched(),a_action.state());
reset_touched();
}}
a_action.add_one_point(0,0,0);
/*
{tools_vforcit(line_t,m_lines,it) {
const line_t& item = *it;
size_t num = item.second;
const float* data = tools::vec_data<float>(m_xys)+item.first;
float px,py,pz;
float* pos = (float*)data;
for(size_t index=0;index<num;index++) {
px = *pos;pos++;
py = *pos;pos++;
pz = 0;
a_action.add_one_point(px,py,pz);
}
}}
///////////////////////////////////////////////////////////
/// triangles /////////////////////////////////////////////
///////////////////////////////////////////////////////////
{tools_vforcit(gl_triangle_t,m_triangles,it) {
const std::pair<GLUenum,triangle_t>& item = *it;
size_t num = item.second.second;
const float* data = tools::vec_data<float>(m_xys)+item.second.first;
float px,py,pz;
float* pos = (float*)data;
for(size_t index=0;index<num;index++) {
px = *pos;pos++;
py = *pos;pos++;
pz = 0;
a_action.add_one_point(px,py,pz);
}
}}
///////////////////////////////////////////////////////////
/// bitmap ////////////////////////////////////////////////
///////////////////////////////////////////////////////////
m_bitmaps.bbox(a_action);
*/
}
public:
text_freetype_marker():parent(){
height = 10; //pixels
}
virtual ~text_freetype_marker(){}
public:
text_freetype_marker(const text_freetype_marker& a_from):parent(a_from) {}
text_freetype_marker& operator=(const text_freetype_marker& a_from){parent::operator=(a_from);return *this;}
protected:
void update_sg(std::ostream& a_out,bool a_load_font,const tools::sg::state& a_state) {
if(!a_state.m_wh) {parent::update_sg(a_out,a_load_font);return;}
float sy = 2.0f*float(height.value())/float(a_state.m_wh); //in [-1,1]
float old_height = height.value();
height.value_no_cmp(sy);
//update_what what = lines;
//if(modeling==tools::sg::font_filled) what = faces_and_lines;
parent::update_sg(a_out,a_load_font);
height.value_no_cmp(old_height);
}
float* _trans2(size_t a_num,const float* a_data,float a_x,float a_y) {
float* vp = new float[a_num*2];
if(!vp) return 0;
float* pos = vp;
float* pda = (float*)a_data;
for(size_t index=0;index<a_num;index++){
*pos = *pda + a_x;pos++;pda++;
*pos = *pda + a_y;pos++;pda++;
}
return vp;
}
};
}}
#endif
source/externals/g4tools/include/tools/sg/text_hershey
Vendored
+6 -6
View File
@@ -586,7 +586,7 @@ protected:
static void decode_PAW(const std::string& a_s,sencoded& a_sed){
a_sed.clear();
font_type font = sg::latin;
font_type hershey_font = sg::latin;
hchar::e_move move = hchar::none;
bool back = false;
bool bar = false;
@@ -596,16 +596,16 @@ protected:
char c = *it;
// Control characters :
if(c=='[') {
font = sg::greek;
hershey_font = sg::greek;
continue;
} else if(c==']') {
font = sg::latin;
hershey_font = sg::latin;
continue;
} else if(c=='"') {
font = sg::special;
hershey_font = sg::special;
continue;
} else if(c=='#') {
font = sg::latin;
hershey_font = sg::latin;
continue;
} else if(c=='!') {
move = hchar::none;
@@ -631,7 +631,7 @@ protected:
hc.m_y_move = move;
hc.m_back = back;
hc.m_bar = bar;
hc.m_font = font;
hc.m_font = hershey_font;
hc.m_char = c;
a_sed.push_back(hc);