KstBindAxis::KstBindAxis(KJS::ExecState *exec, Kst2DPlotPtr d, bool isX)
: QObject(), KstBinding("Axis", false), _d(d.data()), _xAxis(isX) {
  KJS::Object o(this);
  addBindings(exec, o);
}
Example #2
0
void foo()
{
  Empty e;
  Other o(e);
  bar(o);
}
KstBindPoint::KstBindPoint(KJS::ExecState *exec, double x, double y)
: KstBinding("Point"), _x(x), _y(y) {
  KJS::Object o(this);
  addBindings(exec, o);
}
Example #4
0
 rarray Env::array_new(int size) {
   return o(Array::create(private_->state(), size));
 }
Example #5
0
int main(int argc, char** argv)
{

  int ppw=10;     // Point per wavelength
  std::string file="/home/tbetcke/svn/numerical_coercivity/data/trapping";

  int numrange_n=50; // Number of discretization points for num. range.
  int computenorm=0; // Set to 1 to compute norm and condition number
  
 
  std::vector<double> freqs;
  freqs.push_back(8);
  //freqs.push_back(10);
  //freqs.push_back(50);
  //freqs.push_back(100);
  //freqs.push_back(200);
  //freqs.push_back(500);

        clock_t start, finish;
        double time;
        start=clock();
 

        double a=0.31;
        double c=1;
        double l=c-a;

        std::vector<bem2d::Point> trapping;
        trapping.push_back(bem2d::Point(0,0));
        trapping.push_back(bem2d::Point(-c,0));
        trapping.push_back(bem2d::Point(-c,-l));
        trapping.push_back(bem2d::Point(l,-l));
        trapping.push_back(bem2d::Point(l,2*c-l));
        trapping.push_back(bem2d::Point(-c,2*c-l));
        trapping.push_back(bem2d::Point(-c,2*a));
        trapping.push_back(bem2d::Point(0,2*a));




#ifdef BEM2DMPI
        MPI_Init(&argc, &argv);


        int nprow=2; // Number of rows in process grid
        int npcol=1; // Number of columns in process grid
        int mb=24;  // Row Block size
        int nb=24;  // Column Block size
        bem2d::BlacsSystem* b=bem2d::BlacsSystem::Initialize(nprow,npcol,mb,nb);

	// Exit if Context could not be created or process does not belong to context

        if (!b) {
                std::cout <<  "Could not create Blacs context" << std::endl;
                MPI_Finalize();
                exit(1);
        }
        if ((b->get_myrow()==-1)&&(b->get_mycol()==-1)) {
                MPI_Finalize();
                exit(0);
        }
#endif

	for (int j=0;j<freqs.size();j++){

	  bem2d::freqtype k={(double)freqs[j],0};
	double eta1=k.re; // Coupling between conj. double and single layer pot.
	bem2d::Polygon poly(trapping,ppw,k,10,0.15);
        bem2d::pGeometry pgeom=poly.GetGeometry();
	bem2d::WriteDomain("/home/svn/numerical_coercivity/data/trapping_shape",pgeom,5);

        bem2d::PolBasis::AddBasis(2,pgeom); // Add constant basis functions


	// Discretize the single and double layer potential

	bem2d::SingleLayer sl(k);
	bem2d::ConjDoubleLayer cdl(k);

	bem2d::QuadOption quadopts;

	quadopts.L=3;
        quadopts.N=5;
        quadopts.sigma=0.15;

#ifdef BEM2DMPI
	if (b->IsRoot()){
	  std::cout << "Discretize Kernels with n=" << pgeom->size() << std::endl;
	}
#else
	std::cout << "Discretize Kernels with n=" << pgeom->size() << std::endl;
#endif



	bem2d::Matrix dsl=*(DiscreteKernel(*pgeom,quadopts,sl));
	bem2d::Matrix dcdl=*(DiscreteKernel(*pgeom,quadopts,cdl));
	bem2d::Matrix Id=*(EvalIdent(*pgeom, quadopts));
	bem2d::Matrix combined1=Id+2.0*dcdl-bem2d::complex(0,2.0)*eta1*dsl;
	
	combined1=bem2d::ChangeBasis(combined1,Id);

#ifdef BEM2DMPI
	if (b->IsRoot()){
	  std::cout << "Compute Eigenvalues and norm" << std::endl;
	}
#else
	std::cout << "Compute Eigenvalues and norm" << std::endl;
#endif

	double norm; double cond;
	
	bem2d::pcvector eigvals;
	bem2d::Eigenvalues(combined1,eigvals);

	if (computenorm){
	bem2d::L2NormCond(combined1,norm,cond);


	// Write out norm and condition number

#ifdef BEM2DMPI
	if (b->IsRoot()){
#endif

	  std::ostringstream osnormcond;
	  osnormcond << file << "_normcond_" << k.re; 
	  std::string s0=osnormcond.str();
	  std::ofstream o(s0.c_str());
	  o << norm << std::endl << cond << std::endl;
	  o.close();
#ifdef BEM2DMPI
	}
#endif
	}

	// Write out eigenvalues

#ifdef BEM2DMPI
	if (b->IsRoot()){
#endif

	  std::ostringstream os;
	  os << file << "_eig_" << k.re; 
	  std::string s=os.str();
	  std::ofstream o1(s.c_str());
	  for (int i=0;i<eigvals->size();i++) o1 << std::real((*eigvals)[i])
			     << " " << std::imag((*eigvals)[i]) << std::endl;
	  o1.close();
#ifdef BEM2DMPI
	}
#endif

	

#ifdef BEM2DMPI
	if (b->IsRoot()){
	  std::cout << "Compute Numerical Range" << std::endl;
	}
#else
	std::cout << "Compute Numerical Range" << std::endl;
#endif


	std::ostringstream os2;
	os2 << file << "_range_" << k.re;
	NumRange(combined1, numrange_n, os2.str());

	
	}
        finish=clock();
        time=(double(finish)-double(start))/CLOCKS_PER_SEC/60;

#ifdef BEM2DMPI
        bem2d::BlacsSystem::Release();
        MPI_Finalize();
#endif

}
Example #6
0
 rstring Env::to_s(robject obj) {
   return o(s(obj)->to_s(private_->state()));
 }
Example #7
0
 rsymbol Env::method_file(rcompiled_code code) {
   return o(i(code)->file());
 }
static void TransformsAndCenters(
	vector<TAffine>			&transforms,
	vector<Point>			&centers,
	const vector<triangle>	&tri,
	const vector<Point>		&orig,
	const vector<Point>		&cpts,
	const TAffine			&tr_guess,
	FILE*					flog )
{
	fprintf( flog, "\n---- Transforms ----\n" );

	int	ntri = tri.size();

	for( int k = 0; k < ntri; ++k ) {

		const triangle&	T  = tri[k];
		int				i0 = T.v[0],
						i1 = T.v[1],
						i2 = T.v[2];

		// Find transformation that maps original control points
		// (orig) into optimized (cpts).
		//
		// Begin with a transform mapping a unit right triangle
		// { (0,0), (1,0), (0,1) } in abstract global space to
		// the respective orig vertices { o0, o1, o2 }. To see
		// how simple this really is, just apply the TAffine (o)
		// that we define below to each of the global vertices.

		const Point&	o0 = orig[i0],
						o1 = orig[i1],
						o2 = orig[i2];

		TAffine	o(	o1.x - o0.x, o2.x - o0.x, o0.x,
					o1.y - o0.y, o2.y - o0.y, o0.y );

		// And make a like mapping from global space to (cpts)

		const Point&	c0 = cpts[i0],
						c1 = cpts[i1],
						c2 = cpts[i2];

		TAffine	c(	c1.x - c0.x, c2.x - c0.x, c0.x,
					c1.y - c0.y, c2.y - c0.y, c0.y );

		// Now make transform t = c * o-inv from orig to cpts

		TAffine	t, oi;

		oi.InverseOf( o );
		t = c * oi;

		t.TPrint( flog );

		// Sanity check the "angular" change

		if(	(fabs( t.t[0] - 1.0 ) > 0.1 &&
			 fabs( t.t[0] - tr_guess.t[0] ) > 0.1)
			||
			(fabs( t.t[4] - 1.0 ) > 0.1 &&
			 fabs( t.t[4] - tr_guess.t[4] ) > 0.1) ) {

			fprintf( flog,
			"Large deviation in t[0], t[4]: vertices %d %d %d\n",
			i0, i1, i2 );

			fprintf( flog,
			"orig (%f %f) (%f %f) (%f %f).\n",
			o0.x, o0.y, o1.x, o1.y, o2.x, o2.y );

			fprintf( flog,
			"cpts (%f %f) (%f %f) (%f %f)\n",
			c0.x, c0.y, c1.x, c1.y, c2.x, c2.y );
		}

		transforms.push_back( t );

		// Each center is initially just a triangle centroid,
		// although any point interior to triangle will do.

		double	cenx = (o0.x + o1.x + o2.x) / 3.0,
				ceny = (o0.y + o1.y + o2.y) / 3.0;

		// Now we jiggle along a line segment from centroid
		// to vertex 0. The purpose is that in rare instances
		// when affines are all the same because optimizer did
		// nothing, if centers are also colinear, then solver
		// matrices become degenerate. Jiggling avoids that.

		double	seglenscl = double(rand()) / (10.0 * RAND_MAX);

		cenx += seglenscl * (o0.x - cenx);
		ceny += seglenscl * (o0.y - ceny);

		centers.push_back( Point( cenx, ceny ) );
	}
}
Example #9
0
 rsymbol Env::method_file(rmethod code) {
   return o(i(code)->file());
 }
Example #10
0
KstBindDataVector::KstBindDataVector(KJS::ExecState *exec, KstRVectorPtr v)
: KstBindVector(exec, v.data(), "DataVector") {
  KJS::Object o(this);
  addBindings(exec, o);
}
Example #11
0
KstBindDataVector::KstBindDataVector(KJS::ExecState *exec, KJS::Object *globalObject)
: KstBindVector(exec, globalObject, "DataVector") {
  KJS::Object o(this);
  addBindings(exec, o);
}
Example #12
0
void hongocompleto()
{
int i=0;
do{

//for(i=6;i<9;i++)
//{
setbkcolor(WHITE);
construccion();
////C
setcolor (7);
settextstyle (0,0,5);
outtextxy (30,50,"C");
////A
setcolor (7);
settextstyle (0,0,5);
outtextxy (70,55,"A");
/////R
setcolor (7);
settextstyle (0,0,5);
outtextxy (110,50,"R");

/////G
setcolor (7);
settextstyle (0,0,5);
outtextxy (150,55,"G");
/////A
setcolor (7);
settextstyle (0,0,5);
outtextxy (190,50,"A");
/////N
setcolor (7);
settextstyle (0,0,5);
outtextxy (230,55,"N");
/////D
setcolor (7);
settextstyle (0,0,5);
outtextxy (270,50,"D");
/////O
setcolor (7);
settextstyle (0,0,5);
outtextxy (310,55,"O");
c();
//a1();
//r();
//g();
//a2();
//n();
//d();
//o();
//c();
delay(200);
cabeza();
a1();
delay(200);
ojo();
r();

delay(200);
mancha1();
g();
delay(200);

mancha2();
a2();
delay(200);

mancha3();
n();
delay(200);

mancha4();
d();
delay(200);

mancha5();
o();
delay(200);
//getch();
i=i++;

//kbhit();
}while (i<2);
//}while (!kbhit());
}
Example #13
0
void test_o() {
  int* ip1 = o(PromotesToIntValue);
  double* dp1 = o(PromotesToUnsignedIntValue);
}
int main(int argc, char *argv[]) {
	bool error = false;
	uint8_t buffer[256];
	uint16_t bufferSize = 256;
	StreamParser p(streamReader, buffer, bufferSize, handlers, 1, NULL);
	
	while(p.parse() >= 0);
	
	int16_t theInt = 400;
	float theFloat = 213423.23466432;
	uint16_t functionID = 1;
	
	char *stri = (char *)"hello world";
	
	uint8_t indexTable[] = { Object::T_UINT16, Object::T_INT16, Object::T_STRING, Object::T_FLOAT, Object::T_INT32, Object::T_INT64, (uint8_t)(strlen(stri) + 1) };
	Object o(indexTable, 6);
	
	uint8_t dataBuffer[o.getDataSize()];
	o.setDataBuffer(dataBuffer);
	
	o.uint16At(0, functionID); //function id
	o.int16At(1, theInt); //payload argument
	o.strAt(2, stri, strlen(stri) + 1);
	if(!o.floatAt(3, theFloat)) {
		printf("Failed to set float value\n");
	}
	o.int32At(4, 345589619);
	o.int64At(5, 9384760934765065ll);
	
	if(o.int64At(5) != 9384760934765065ll) {
		printf("Retrieved int64 does not equal actual A:%lld, R:%lld\n", (long long int)9384760934765065ll, (long long int)o.int64At(5));
	}
	
	if(o.int32At(4) != 345589619) {
		printf("Retrieved int32 does not equal actual\n");
	}
	
	if(o.floatAt(3) != theFloat) {
		printf("Retrieved float does not equal actual A:%f, R:%f\n", theFloat, o.floatAt(3));
	}
	
	if(o.int16At(1) != theInt) {
		printf("Retrieved int does not equal actual A:%d R:%d\n", theInt, o.int16At(1));
	}
	
	StreamParser::PacketHeader ph = StreamParser::makePacket(16, o.getSize());
	
	printf("generated packet: ");
	printHex(&ph, sizeof(ph));
	o.writeTo(writer, NULL);
	printf("\n");
	
	
	testBuffer = ((uint8_t *)(&ph));
	testBufferSize = sizeof(StreamParser::PacketHeader);
	testBufferIndex = 0;
	
	printf("rpc call: ");
	if(rpc.call(10, "cCds", -10, 10, 320, "hello world") <= 0) {
		printf("error doing rpc call");
	}
	printf("\n");
	
	if(error) {
		printf("FAIELD: Object & RPC buffer tests\n");
	} else {
		printf("PASSED: Object & RPC buffer tests\n");
	}

	printf("Calling socket tests\n");
	socketTest();
	printf("PASSED: Socket Tests\n");

}
Example #15
0
 rstring Env::symbol_to_string(rsymbol sym) {
   return o(i(sym)->to_str(private_->state()));
 }
 void DebugWindow::setText(const Ogre::String& text)
 {
     CeGuiString o(text.c_str());
     mText->setText(o);
 }
Example #17
0
 rstring Env::string_new(const char* ptr) {
   return o(String::create(private_->state(), ptr));
 }
Example #18
0
/**
 * Use pipe_screen::get_param() to query PIPE_CAP_ values to determine
 * which GL extensions are supported.
 * Quite a few extensions are always supported because they are standard
 * features or can be built on top of other gallium features.
 * Some fine tuning may still be needed.
 */
void st_init_extensions(struct st_context *st)
{
   struct pipe_screen *screen = st->pipe->screen;
   struct gl_context *ctx = st->ctx;
   int i, glsl_feature_level;
   GLboolean *extensions = (GLboolean *) &ctx->Extensions;

   static const struct st_extension_cap_mapping cap_mapping[] = {
      { o(ARB_base_instance),                PIPE_CAP_START_INSTANCE                   },
      { o(ARB_buffer_storage),               PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT },
      { o(ARB_depth_clamp),                  PIPE_CAP_DEPTH_CLIP_DISABLE               },
      { o(ARB_depth_texture),                PIPE_CAP_TEXTURE_SHADOW_MAP               },
      { o(ARB_draw_buffers_blend),           PIPE_CAP_INDEP_BLEND_FUNC                 },
      { o(ARB_draw_instanced),               PIPE_CAP_TGSI_INSTANCEID                  },
      { o(ARB_fragment_program_shadow),      PIPE_CAP_TEXTURE_SHADOW_MAP               },
      { o(ARB_instanced_arrays),             PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR  },
      { o(ARB_occlusion_query),              PIPE_CAP_OCCLUSION_QUERY                  },
      { o(ARB_occlusion_query2),             PIPE_CAP_OCCLUSION_QUERY                  },
      { o(ARB_point_sprite),                 PIPE_CAP_POINT_SPRITE                     },
      { o(ARB_seamless_cube_map),            PIPE_CAP_SEAMLESS_CUBE_MAP                },
      { o(ARB_shader_stencil_export),        PIPE_CAP_SHADER_STENCIL_EXPORT            },
      { o(ARB_shader_texture_lod),           PIPE_CAP_SM3                              },
      { o(ARB_shadow),                       PIPE_CAP_TEXTURE_SHADOW_MAP               },
      { o(ARB_texture_mirror_clamp_to_edge), PIPE_CAP_TEXTURE_MIRROR_CLAMP             },
      { o(ARB_texture_non_power_of_two),     PIPE_CAP_NPOT_TEXTURES                    },
      { o(ARB_timer_query),                  PIPE_CAP_QUERY_TIMESTAMP                  },
      { o(ARB_transform_feedback2),          PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME       },
      { o(ARB_transform_feedback3),          PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME       },

      { o(EXT_blend_equation_separate),      PIPE_CAP_BLEND_EQUATION_SEPARATE          },
      { o(EXT_draw_buffers2),                PIPE_CAP_INDEP_BLEND_ENABLE               },
      { o(EXT_stencil_two_side),             PIPE_CAP_TWO_SIDED_STENCIL                },
      { o(EXT_texture_array),                PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS         },
      { o(EXT_texture_filter_anisotropic),   PIPE_CAP_ANISOTROPIC_FILTER               },
      { o(EXT_texture_mirror_clamp),         PIPE_CAP_TEXTURE_MIRROR_CLAMP             },
      { o(EXT_texture_swizzle),              PIPE_CAP_TEXTURE_SWIZZLE                  },
      { o(EXT_transform_feedback),           PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS        },

      { o(AMD_seamless_cubemap_per_texture), PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE    },
      { o(ATI_separate_stencil),             PIPE_CAP_TWO_SIDED_STENCIL                },
      { o(ATI_texture_mirror_once),          PIPE_CAP_TEXTURE_MIRROR_CLAMP             },
      { o(NV_conditional_render),            PIPE_CAP_CONDITIONAL_RENDER               },
      { o(NV_texture_barrier),               PIPE_CAP_TEXTURE_BARRIER                  },
      /* GL_NV_point_sprite is not supported by gallium because we don't
       * support the GL_POINT_SPRITE_R_MODE_NV option. */

      { o(OES_standard_derivatives),         PIPE_CAP_SM3                              },
      { o(ARB_texture_cube_map_array),       PIPE_CAP_CUBE_MAP_ARRAY                   },
      { o(ARB_texture_multisample),          PIPE_CAP_TEXTURE_MULTISAMPLE              },
      { o(ARB_texture_query_lod),            PIPE_CAP_TEXTURE_QUERY_LOD                },
      { o(ARB_sample_shading),               PIPE_CAP_SAMPLE_SHADING                   },
   };

   /* Required: render target and sampler support */
   static const struct st_extension_format_mapping rendertarget_mapping[] = {
      { { o(ARB_texture_float) },
        { PIPE_FORMAT_R32G32B32A32_FLOAT,
          PIPE_FORMAT_R16G16B16A16_FLOAT } },

      { { o(ARB_texture_rgb10_a2ui) },
        { PIPE_FORMAT_R10G10B10A2_UINT,
          PIPE_FORMAT_B10G10R10A2_UINT },
         GL_TRUE }, /* at least one format must be supported */

      { { o(EXT_framebuffer_sRGB) },
        { PIPE_FORMAT_A8B8G8R8_SRGB,
          PIPE_FORMAT_B8G8R8A8_SRGB },
         GL_TRUE }, /* at least one format must be supported */

      { { o(EXT_packed_float) },
        { PIPE_FORMAT_R11G11B10_FLOAT } },

      { { o(EXT_texture_integer) },
        { PIPE_FORMAT_R32G32B32A32_UINT,
          PIPE_FORMAT_R32G32B32A32_SINT } },

      { { o(ARB_texture_rg) },
        { PIPE_FORMAT_R8_UNORM,
          PIPE_FORMAT_R8G8_UNORM } },
   };

   /* Required: depth stencil and sampler support */
   static const struct st_extension_format_mapping depthstencil_mapping[] = {
      { { o(ARB_depth_buffer_float) },
        { PIPE_FORMAT_Z32_FLOAT,
          PIPE_FORMAT_Z32_FLOAT_S8X24_UINT } },
   };

   /* Required: sampler support */
   static const struct st_extension_format_mapping texture_mapping[] = {
      { { o(ARB_texture_compression_rgtc) },
        { PIPE_FORMAT_RGTC1_UNORM,
          PIPE_FORMAT_RGTC1_SNORM,
          PIPE_FORMAT_RGTC2_UNORM,
          PIPE_FORMAT_RGTC2_SNORM } },

      { { o(EXT_texture_compression_latc) },
        { PIPE_FORMAT_LATC1_UNORM,
          PIPE_FORMAT_LATC1_SNORM,
          PIPE_FORMAT_LATC2_UNORM,
          PIPE_FORMAT_LATC2_SNORM } },

      { { o(EXT_texture_compression_s3tc),
          o(ANGLE_texture_compression_dxt) },
        { PIPE_FORMAT_DXT1_RGB,
          PIPE_FORMAT_DXT1_RGBA,
          PIPE_FORMAT_DXT3_RGBA,
          PIPE_FORMAT_DXT5_RGBA } },

      { { o(EXT_texture_shared_exponent) },
        { PIPE_FORMAT_R9G9B9E5_FLOAT } },

      { { o(EXT_texture_snorm) },
        { PIPE_FORMAT_R8G8B8A8_SNORM } },

      { { o(EXT_texture_sRGB),
          o(EXT_texture_sRGB_decode) },
        { PIPE_FORMAT_A8B8G8R8_SRGB,
          PIPE_FORMAT_B8G8R8A8_SRGB },
        GL_TRUE }, /* at least one format must be supported */

      { { o(ATI_texture_compression_3dc) },
        { PIPE_FORMAT_LATC2_UNORM } },

      { { o(MESA_ycbcr_texture) },
        { PIPE_FORMAT_UYVY,
          PIPE_FORMAT_YUYV },
        GL_TRUE }, /* at least one format must be supported */

      { { o(OES_compressed_ETC1_RGB8_texture) },
        { PIPE_FORMAT_ETC1_RGB8 } },

      { { o(ARB_stencil_texturing) },
        { PIPE_FORMAT_X24S8_UINT,
          PIPE_FORMAT_S8X24_UINT },
        GL_TRUE }, /* at least one format must be supported */
   };

   /* Required: vertex fetch support. */
   static const struct st_extension_format_mapping vertex_mapping[] = {
      { { o(ARB_vertex_type_2_10_10_10_rev) },
        { PIPE_FORMAT_R10G10B10A2_UNORM,
          PIPE_FORMAT_B10G10R10A2_UNORM,
          PIPE_FORMAT_R10G10B10A2_SNORM,
          PIPE_FORMAT_B10G10R10A2_SNORM,
          PIPE_FORMAT_R10G10B10A2_USCALED,
          PIPE_FORMAT_B10G10R10A2_USCALED,
          PIPE_FORMAT_R10G10B10A2_SSCALED,
          PIPE_FORMAT_B10G10R10A2_SSCALED } },
      { { o(ARB_vertex_type_10f_11f_11f_rev) },
        { PIPE_FORMAT_R11G11B10_FLOAT } },
   };

   static const struct st_extension_format_mapping tbo_rgb32[] = {
      { {o(ARB_texture_buffer_object_rgb32) },
        { PIPE_FORMAT_R32G32B32_FLOAT,
          PIPE_FORMAT_R32G32B32_UINT,
          PIPE_FORMAT_R32G32B32_SINT,
        } },
   };

   /*
    * Extensions that are supported by all Gallium drivers:
    */
   ctx->Extensions.ARB_ES2_compatibility = GL_TRUE;
   ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;
   ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE;
   ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;
   ctx->Extensions.ARB_fragment_program = GL_TRUE;
   ctx->Extensions.ARB_fragment_shader = GL_TRUE;
   ctx->Extensions.ARB_half_float_vertex = GL_TRUE;
   ctx->Extensions.ARB_internalformat_query = GL_TRUE;
   ctx->Extensions.ARB_map_buffer_range = GL_TRUE;
   ctx->Extensions.ARB_texture_border_clamp = GL_TRUE; /* XXX temp */
   ctx->Extensions.ARB_texture_cube_map = GL_TRUE;
   ctx->Extensions.ARB_texture_env_combine = GL_TRUE;
   ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;
   ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;
   ctx->Extensions.ARB_vertex_program = GL_TRUE;
   ctx->Extensions.ARB_vertex_shader = GL_TRUE;

   ctx->Extensions.EXT_blend_color = GL_TRUE;
   ctx->Extensions.EXT_blend_func_separate = GL_TRUE;
   ctx->Extensions.EXT_blend_minmax = GL_TRUE;
   ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;
   ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;
   ctx->Extensions.EXT_point_parameters = GL_TRUE;
   ctx->Extensions.EXT_provoking_vertex = GL_TRUE;

   ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE;
   ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;

   ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE;

   ctx->Extensions.MESA_pack_invert = GL_TRUE;

   ctx->Extensions.NV_fog_distance = GL_TRUE;
   ctx->Extensions.NV_texture_env_combine4 = GL_TRUE;
   ctx->Extensions.NV_texture_rectangle = GL_TRUE;
   ctx->Extensions.NV_vdpau_interop = GL_TRUE;

   ctx->Extensions.OES_EGL_image = GL_TRUE;
   ctx->Extensions.OES_EGL_image_external = GL_TRUE;
   ctx->Extensions.OES_draw_texture = GL_TRUE;

   /* Expose the extensions which directly correspond to gallium caps. */
   for (i = 0; i < Elements(cap_mapping); i++) {
      if (screen->get_param(screen, cap_mapping[i].cap)) {
         extensions[cap_mapping[i].extension_offset] = GL_TRUE;
      }
   }

   /* Expose the extensions which directly correspond to gallium formats. */
   init_format_extensions(st, rendertarget_mapping,
                          Elements(rendertarget_mapping), PIPE_TEXTURE_2D,
                          PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW);
   init_format_extensions(st, depthstencil_mapping,
                          Elements(depthstencil_mapping), PIPE_TEXTURE_2D,
                          PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_SAMPLER_VIEW);
   init_format_extensions(st, texture_mapping, Elements(texture_mapping),
                          PIPE_TEXTURE_2D, PIPE_BIND_SAMPLER_VIEW);
   init_format_extensions(st, vertex_mapping, Elements(vertex_mapping),
                          PIPE_BUFFER, PIPE_BIND_VERTEX_BUFFER);

   /* Figure out GLSL support. */
   glsl_feature_level = screen->get_param(screen, PIPE_CAP_GLSL_FEATURE_LEVEL);

   ctx->Const.GLSLVersion = glsl_feature_level;
   if (glsl_feature_level >= 330)
      ctx->Const.GLSLVersion = 330;

   _mesa_override_glsl_version(st->ctx);

   if (st->options.force_glsl_version > 0 &&
       st->options.force_glsl_version <= ctx->Const.GLSLVersion) {
      ctx->Const.ForceGLSLVersion = st->options.force_glsl_version;
   }

   /* This extension needs full OpenGL 3.2, but we don't know if that's
    * supported at this point. Only check the GLSL version. */
   if (ctx->Const.GLSLVersion >= 150 &&
       screen->get_param(screen, PIPE_CAP_TGSI_VS_LAYER)) {
      ctx->Extensions.AMD_vertex_shader_layer = GL_TRUE;
   }

   if (ctx->Const.GLSLVersion >= 130) {
      ctx->Const.NativeIntegers = GL_TRUE;
      ctx->Const.MaxClipPlanes = 8;

      /* Extensions that either depend on GLSL 1.30 or are a subset thereof. */
      ctx->Extensions.ARB_conservative_depth = GL_TRUE;
      ctx->Extensions.ARB_shading_language_packing = GL_TRUE;
      ctx->Extensions.OES_depth_texture_cube_map = GL_TRUE;
      ctx->Extensions.ARB_shading_language_420pack = GL_TRUE;

      if (!st->options.disable_shader_bit_encoding) {
         ctx->Extensions.ARB_shader_bit_encoding = GL_TRUE;
      }

      ctx->Extensions.EXT_shader_integer_mix = GL_TRUE;
   } else {
      /* Optional integer support for GLSL 1.2. */
      if (screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
                                   PIPE_SHADER_CAP_INTEGERS) &&
          screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
                                   PIPE_SHADER_CAP_INTEGERS)) {
         ctx->Const.NativeIntegers = GL_TRUE;

         ctx->Extensions.EXT_shader_integer_mix = GL_TRUE;
      }
   }

   /* Below are the cases which cannot be moved into tables easily. */

   if (!ctx->Mesa_DXTn && !st->options.force_s3tc_enable) {
      ctx->Extensions.EXT_texture_compression_s3tc = GL_FALSE;
      ctx->Extensions.ANGLE_texture_compression_dxt = GL_FALSE;
   }

   if (screen->get_shader_param(screen, PIPE_SHADER_GEOMETRY,
                                PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) {
#if 0 /* XXX re-enable when GLSL compiler again supports geometry shaders */
      ctx->Extensions.ARB_geometry_shader4 = GL_TRUE;
#endif
   }

   ctx->Extensions.NV_primitive_restart = GL_TRUE;
   if (!screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART)) {
      ctx->Const.PrimitiveRestartInSoftware = GL_TRUE;
   }

   /* ARB_color_buffer_float. */
   if (screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_UNCLAMPED)) {
      ctx->Extensions.ARB_color_buffer_float = GL_TRUE;

      if (!screen->get_param(screen, PIPE_CAP_VERTEX_COLOR_CLAMPED)) {
         st->clamp_vert_color_in_shader = TRUE;
      }

      if (!screen->get_param(screen, PIPE_CAP_FRAGMENT_COLOR_CLAMPED)) {
         st->clamp_frag_color_in_shader = TRUE;
      }

      /* For drivers which cannot do color clamping, it's better to just
       * disable ARB_color_buffer_float in the core profile, because
       * the clamping is deprecated there anyway. */
      if (ctx->API == API_OPENGL_CORE &&
          (st->clamp_frag_color_in_shader || st->clamp_vert_color_in_shader)) {
         st->clamp_vert_color_in_shader = GL_FALSE;
         st->clamp_frag_color_in_shader = GL_FALSE;
         ctx->Extensions.ARB_color_buffer_float = GL_FALSE;
      }
   }

   if (screen->fence_finish) {
      ctx->Extensions.ARB_sync = GL_TRUE;
   }

   /* Maximum sample count. */
   for (i = 16; i > 0; --i) {
      enum pipe_format pformat = st_choose_format(st, GL_RGBA,
                                                  GL_NONE, GL_NONE,
                                                  PIPE_TEXTURE_2D, i,
                                                  PIPE_BIND_RENDER_TARGET, FALSE);
      if (pformat != PIPE_FORMAT_NONE) {
         ctx->Const.MaxSamples = i;
         ctx->Const.MaxColorTextureSamples = i;
         break;
      }
   }
   for (i = ctx->Const.MaxSamples; i > 0; --i) {
      enum pipe_format pformat = st_choose_format(st, GL_DEPTH_STENCIL,
                                                  GL_NONE, GL_NONE,
                                                  PIPE_TEXTURE_2D, i,
                                                  PIPE_BIND_DEPTH_STENCIL, FALSE);
      if (pformat != PIPE_FORMAT_NONE) {
         ctx->Const.MaxDepthTextureSamples = i;
         break;
      }
   }
   for (i = ctx->Const.MaxSamples; i > 0; --i) {
      enum pipe_format pformat = st_choose_format(st, GL_RGBA_INTEGER,
                                                  GL_NONE, GL_NONE,
                                                  PIPE_TEXTURE_2D, i,
                                                  PIPE_BIND_RENDER_TARGET, FALSE);
      if (pformat != PIPE_FORMAT_NONE) {
         ctx->Const.MaxIntegerSamples = i;
         break;
      }
   }
   if (ctx->Const.MaxSamples == 1) {
      /* one sample doesn't really make sense */
      ctx->Const.MaxSamples = 0;
   }
   else if (ctx->Const.MaxSamples >= 2) {
      ctx->Extensions.EXT_framebuffer_multisample = GL_TRUE;
      ctx->Extensions.EXT_framebuffer_multisample_blit_scaled = GL_TRUE;
   }

   if (ctx->Const.MaxSamples == 0 && screen->get_param(screen, PIPE_CAP_FAKE_SW_MSAA)) {
	ctx->Const.FakeSWMSAA = GL_TRUE;
        ctx->Extensions.EXT_framebuffer_multisample = GL_TRUE;
        ctx->Extensions.EXT_framebuffer_multisample_blit_scaled = GL_TRUE;
        ctx->Extensions.ARB_texture_multisample = GL_TRUE;
   }

   if (ctx->Const.MaxDualSourceDrawBuffers > 0 &&
       !st->options.disable_blend_func_extended)
      ctx->Extensions.ARB_blend_func_extended = GL_TRUE;

   st->has_time_elapsed =
      screen->get_param(screen, PIPE_CAP_QUERY_TIME_ELAPSED);

   if (st->has_time_elapsed ||
       ctx->Extensions.ARB_timer_query) {
      ctx->Extensions.EXT_timer_query = GL_TRUE;
   }

   if (ctx->Extensions.ARB_transform_feedback2 &&
       ctx->Extensions.ARB_draw_instanced) {
      ctx->Extensions.ARB_transform_feedback_instanced = GL_TRUE;
   }
   if (st->options.force_glsl_extensions_warn)
      ctx->Const.ForceGLSLExtensionsWarn = 1;

   if (st->options.disable_glsl_line_continuations)
      ctx->Const.DisableGLSLLineContinuations = 1;

   ctx->Const.MinMapBufferAlignment =
      screen->get_param(screen, PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT);

   if (screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OBJECTS)) {
      ctx->Extensions.ARB_texture_buffer_object = GL_TRUE;

      ctx->Const.MaxTextureBufferSize =
         _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE),
              (1u << 31) - 1);
      ctx->Const.TextureBufferOffsetAlignment =
         screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT);

      if (ctx->Const.TextureBufferOffsetAlignment)
         ctx->Extensions.ARB_texture_buffer_range = GL_TRUE;

      init_format_extensions(st, tbo_rgb32, Elements(tbo_rgb32),
                             PIPE_BUFFER, PIPE_BIND_SAMPLER_VIEW);
   }

   if (screen->get_param(screen, PIPE_CAP_MIXED_FRAMEBUFFER_SIZES)) {
      ctx->Extensions.ARB_framebuffer_object = GL_TRUE;
   }

   /* Unpacking a varying in the fragment shader costs 1 texture indirection.
    * If the number of available texture indirections is very limited, then we
    * prefer to disable varying packing rather than run the risk of varying
    * packing preventing a shader from running.
    */
   if (screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
                                PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS) <= 8) {
      /* We can't disable varying packing if transform feedback is available,
       * because transform feedback code assumes a packed varying layout.
       */
      if (!ctx->Extensions.EXT_transform_feedback)
         ctx->Const.DisableVaryingPacking = GL_TRUE;
   }

   if (ctx->API == API_OPENGL_CORE) {
      ctx->Const.MaxViewports = screen->get_param(screen, PIPE_CAP_MAX_VIEWPORTS);
      if (ctx->Const.MaxViewports >= 16) {
         ctx->Const.ViewportBounds.Min = -16384.0;
         ctx->Const.ViewportBounds.Max = 16384.0;
         ctx->Extensions.ARB_viewport_array = GL_TRUE;
      }
   }
   if (ctx->Const.MaxProgramTextureGatherComponents > 0)
      ctx->Extensions.ARB_texture_gather = GL_TRUE;
}
Example #19
0
 rsymbol Env::string_to_symbol(rstring str) {
   return o(i(str)->to_sym(private_->state()));
 }
KstBindPluginManager::KstBindPluginManager(KJS::ExecState *exec)
: KstBinding("PluginManager", false) {
  KJS::Object o(this);
  addBindings(exec, o);
}
Example #21
0
 rtable Env::table_new() {
   return o(LookupTable::create(private_->state()));
 }
// @node	maya shader node name
void Visitor::visitFile(const char* node)
{	
	CM_TRACE_FUNC("Visitor::visitFile("<<node<<")");

	OutputHelper o(RSLfile);

	o.addInclude("file.h");

	o.beginRSL( node );

	MString mayaTexName(getFileNodeImageName(node));
	MString texName = mayaTexName + ".tex";
	//system("txmake mayaTexName texName");
	IfMErrorWarn(MGlobal::executeCommand("system(\"txmake "+mayaTexName+" "+texName+"\")", true));

	//input
	o.addRSLVariable(       "", "float",  "alphaGain",		"alphaGain",	node);
	o.addRSLVariable("uniform", "float",  "alphaIsLuminance",	"alphaIsLuminance",	node);
	o.addRSLVariable(       "", "float",  "alphaOffset",	"alphaOffset",	node);
	o.addRSLVariable(       "", "color",  "colorGain",		"colorGain",	node);
	o.addRSLVariable(       "", "color",  "colorOffset",	"colorOffset",	node);
	o.addRSLVariable(       "", "color",  "defaultColor",	"defaultColor",	node);
	o.addRSLVariable(       "", "float2", "uvCoord",		"uvCoord",node);
	//texName
	o.addRSLVariable("uniform", "float", "filterType",		"filterType",	node);
	o.addRSLVariable("uniform", "float", "filter",			"filter",		node);
	o.addRSLVariable(       "", "float", "filterOffset",	"filterOffset",	node);
	o.addRSLVariable("uniform", "float", "invert",			"invert",		node);
	o.addRSLVariable("uniform", "float", "fileHasAlpha",	"fileHasAlpha",	node);
	//o.addRSLVariable("index", "num_channels",	"num_channels",	node);
	//output
	o.addRSLVariable(       "", "float", "outAlpha",		"outAlpha",		node);
	o.addRSLVariable(       "", "vector", "outColor",		"outColor",		node);
	o.addRSLVariable(       "", "vector", "outTransparency",	"outTransparency",	node);


	o.addToRSL("{");
	o.addToRSL("  color _outColor;");
	o.addToRSL("  color _outTransparency;");
	o.addToRSL("  maya_file("
						//Inputs
						"alphaGain,         \n\t"
						"alphaIsLuminance,  \n\t"
						"alphaOffset,       \n\t"
						"colorGain,         \n\t"
						"colorOffset,       \n\t"
						"defaultColor,      \n\t"
						"\""+texName+"\",   \n\t"
						"filterType,        \n\t"
						"filter,            \n\t"
						"filterOffset,      \n\t"
						"invert,            \n\t"
						"uvCoord,           \n\t"
						//Outputs
						"outAlpha,          \n\t"
						"_outColor,         \n\t"
						"_outTransparency   \n"
			   "   );");

	o.addToRSL("  outColor        = vector _outColor;");
	o.addToRSL("  outTransparency = vector _outTransparency;");

	o.addToRSL("}");
	o.endRSL();
}
void			ShrubberyCreationForm::action() const
{
	std::ofstream o((this->_target + "_shrubbery").c_str());
	o << "ASCII trees" << std::endl;
}
Example #24
0
RMF::NodeHandle get_node_from_association(RMF::FileHandle nh,
                                          Object *oi) {
  AssociationType o(oi);
  return nh.get_node_from_association(o);
}
Example #25
0
char TmultiScore::debug() {
  QTextStream o(stdout);
  o << "\033[01;35m[SCORE]\033[01;00m";
  return 32;
}
Example #26
0
 rinteger Env::integer_new(r_mint val) {
   return o(Integer::from(private_->state(), val));
 }
Example #27
0
 polynomial& operator=(const polynomial<T>& o)
 {
   vals = std::make_shared<std::vector<T>>(o.size());
   copy_n(&o(0),o.size(),&element(0));
   return *this;
 }
Example #28
0
 rsymbol Env::symbol(const char* data) {
   return o(private_->state()->symbol(data));
 }
Example #29
0
void ClassBinding::write(string dir, const set<string>& includes, string* bindingNS)
{
    // Calculate the constructor string.
    size_t index = uniquename.rfind(SCOPE_REPLACEMENT);
    string constructorString = "";
    string* constructorUniqueName = NULL;
    if (index != uniquename.npos && index != uniquename.length())
        constructorString += uniquename.substr(index + SCOPE_REPLACEMENT_SIZE);
    else
        constructorString += uniquename;

    // Generate a constructor function if there isn't one
    // and the class doesn't have an inaccessible constructor.
    FunctionBinding b(classname, uniquename);
    b.name = constructorString;
    b.returnParam = FunctionBinding::Param(FunctionBinding::Param::TYPE_CONSTRUCTOR, FunctionBinding::Param::KIND_POINTER, refId);
    b.type = FunctionBinding::MEMBER_FUNCTION;
    b.own = true;

    map<string, vector<FunctionBinding> >::iterator iter = bindings.find(b.getFunctionName());
    if (iter == bindings.end())
    {
        if (!inaccessibleConstructor)
        {
            bindings[b.getFunctionName()].push_back(b);
            constructorUniqueName = new string(b.getFunctionName());
        }
    }
    else
    {
        constructorUniqueName = new string(iter->second[0].getFunctionName());
    }

    // Calculate the destructor string.
    index = uniquename.rfind(SCOPE_REPLACEMENT);
    string destructorString = "~";
    string* destructorUniqueName = NULL;
    if (index != uniquename.npos && index != uniquename.length())
        destructorString += uniquename.substr(index + SCOPE_REPLACEMENT_SIZE);
    else
        destructorString += uniquename;

    // Generate a destructor function if there isn't one
    // and the class doesn't have an inaccessible destructor
    // or the class is derived from Ref.
    b = FunctionBinding(classname, uniquename);
    b.name = destructorString;
    b.returnParam = FunctionBinding::Param(FunctionBinding::Param::TYPE_DESTRUCTOR);
    b.type = FunctionBinding::MEMBER_FUNCTION;

    iter = bindings.find(b.getFunctionName());
    if (iter == bindings.end())
    {
        if (!inaccessibleDestructor || Generator::getInstance()->isRef(classname))
        {
            bindings[b.getFunctionName()].push_back(b);
            destructorUniqueName = new string(b.getFunctionName());
        }
    }
    else
    {
        destructorUniqueName = new string(iter->second[0].getFunctionName());
    }

    // Write out the header.
    {
        string path = dir + string("lua_") + uniquename + string(".h");
        ofstream o(path.c_str());
        if (!o)
        {
            GP_ERROR("Failed to open file '%s' for generating Lua bindings.", path.c_str());
            return;
        }

        string includeGuard = string("lua_") + uniquename + string("_H_");
        transform(includeGuard.begin(), includeGuard.end(), includeGuard.begin(), ::toupper);
        o << "#ifndef " << includeGuard << "\n";
        o << "#define " << includeGuard << "\n\n";

        if (bindingNS)
        {
            o << "namespace " << *bindingNS << "\n";
            o << "{\n\n";
        }

        o << "// Lua bindings for " << classname << ".\n";
            
        // Write out the binding functions declarations.
        iter = bindings.begin();
        for (; iter != bindings.end(); iter++)
        {
            o << "int " << iter->second[0].getFunctionName() << "(lua_State* state);\n";
        }
        o << "\n";

        // Write out the signature of the function used to register the class with Lua.
        o << "void luaRegister_" << uniquename << "();\n\n";

        if (bindingNS)
            o << "}\n\n";
        o << "#endif\n";
        o.close();
    }

    // Write out the implementation.
    {
        string path = dir + string("lua_") + uniquename + string(".cpp");
        ofstream o(path.c_str());
        if (!o)
        {
            GP_ERROR("Failed to open file '%s' for generating Lua bindings.", path.c_str());
            return;
        }
        
        o << "#include \"Base.h\"\n";
        o << "#include \"ScriptController.h\"\n";
        o << "#include \"lua_" << uniquename << ".h\"\n";

        // Ensure we include the original class header, even 
        // if the list of includes doesn't have it.
        if (includes.find(include) == includes.end())
            o << "#include \"" << include << "\"\n";

        for (set<string>::iterator includeIter = includes.begin(); includeIter != includes.end(); includeIter++)
        {
            o << "#include \"" << *includeIter << "\"\n";
        }
        o << "\n";
        

        // If the original class is part of a namespace and we aren't generating into that namespace,
        // include its member with a 'using' statement.
        if (ns.length() > 0 && (!bindingNS || (*bindingNS != ns)))
        {
            o << "using " << ns << ";\n\n";
        }

        if (bindingNS)
        {
            o << "namespace " << *bindingNS << "\n";
            o << "{\n\n";
        }

        // Write out the function used to register the class with Lua.
        o << "void luaRegister_" << uniquename << "()\n";
        o << "{\n";
        
        // Get the member functions ready to bind.
        iter = bindings.begin();
        bool hasMembers = false;
        for (; iter != bindings.end(); iter++)
        {
            for (unsigned int i = 0, count = iter->second.size(); i < count; i++)
            {
                if (iter->second[i].type == FunctionBinding::MEMBER_FUNCTION ||
                    iter->second[i].type == FunctionBinding::MEMBER_CONSTANT ||
                    iter->second[i].type == FunctionBinding::MEMBER_VARIABLE)
                {
                    hasMembers = true;
                    break;
                }
            }

            if (hasMembers)
                break;
        }
        if (hasMembers)
        {
            o << "    const luaL_Reg lua_members[] = \n";
            o << "    {\n";
            iter = bindings.begin();
            for (; iter != bindings.end(); iter++)
            {
                for (unsigned int i = 0, count = iter->second.size(); i < count; i++)
                {
                    if ((iter->second[i].type == FunctionBinding::MEMBER_FUNCTION ||
                        iter->second[i].type == FunctionBinding::MEMBER_CONSTANT ||
                        iter->second[i].type == FunctionBinding::MEMBER_VARIABLE) &&
                        iter->second[i].returnParam.type != FunctionBinding::Param::TYPE_CONSTRUCTOR &&
                        iter->second[i].returnParam.type != FunctionBinding::Param::TYPE_DESTRUCTOR)
                    {
                        o << "        {\"" << iter->second[i].name << "\", " << iter->second[i].getFunctionName() << "},\n";
                        break;
                    }
                }
            }
            o << "        {NULL, NULL}\n";
            o << "    };\n";
        }
        else
        {
            o << "    const luaL_Reg* lua_members = NULL;\n";
        }

        // Get the static functions ready to bind.
        iter = bindings.begin();
        bool hasStatics = false;
        for (; iter != bindings.end(); iter++)
        {
            for (unsigned int i = 0, count = iter->second.size(); i < count; i++)
            {
                if (iter->second[i].type == FunctionBinding::STATIC_FUNCTION ||
                    iter->second[i].type == FunctionBinding::STATIC_CONSTANT ||
                    iter->second[i].type == FunctionBinding::STATIC_VARIABLE)
                {
                    hasStatics = true;
                    break;
                }
            }

            if (hasStatics)
                break;
        }
        if (hasStatics)
        {
            o << "    const luaL_Reg lua_statics[] = \n";
            o << "    {\n";
            iter = bindings.begin();
            for (; iter != bindings.end(); iter++)
            {
                for (unsigned int i = 0, count = iter->second.size(); i < count; i++)
                {
                    if (iter->second[i].type == FunctionBinding::STATIC_FUNCTION ||
                    iter->second[i].type == FunctionBinding::STATIC_CONSTANT ||
                    iter->second[i].type == FunctionBinding::STATIC_VARIABLE)
                    {
                        o << "        {\"" << iter->second[i].name << "\", " << iter->second[i].getFunctionName() << "},\n";
                        break;
                    }
                }
            }
            o << "        {NULL, NULL}\n";
            o << "    };\n";
        }
        else
        {
            o << "    const luaL_Reg* lua_statics = NULL;\n";
        }

        // Output the scope path for the class (used for inner classes).
        vector<string> scopePath = Generator::getScopePath(classname, ns);
        o << "    std::vector<std::string> scopePath;\n";
        for (vector<string>::iterator scopeIter = scopePath.begin(); scopeIter != scopePath.end(); scopeIter++)
        {
            o << "    scopePath.push_back(\"" << *scopeIter << "\");\n";
        }

        // Register the class (its member and static functions and constructor and destructor).
        o << "\n    ScriptUtil::registerClass(\"" << uniquename << "\", lua_members, ";
        o << ((constructorUniqueName) ? *constructorUniqueName : "NULL") << ", ";
        o << ((destructorUniqueName) ? *destructorUniqueName : "NULL") << ", ";
        o << "lua_statics, scopePath);\n";
        o << "}\n\n";

        // Write out the function used to get the instance for
        // calling member functions and variables.
        generateInstanceGetter(o, classname, uniquename);

        // Write out the binding functions.
        iter = bindings.begin();
        for (; iter != bindings.end(); iter++)
        {
            FunctionBinding::write(o, iter->second);
        }

        if (bindingNS)
            o << "}\n";
        o.close();
    }

    SAFE_DELETE(constructorUniqueName);
    SAFE_DELETE(destructorUniqueName);
}
Example #30
0
QJsonObject RemDev::newNotification(const QString &method, const QJsonObject &params) const {
	QJsonObject o(rpc_seed);
	o.insert("method", method);
	if (params.size()) o.insert("params", params);
	return o;
}