TLens::TLens(const Math::VectorPair3 &p,
double roc0, double ap_radius0,
double roc1, double ap_radius1,
double thickness0,
const QSharedPointer<TGlass> &glass0,
const QSharedPointer<TGlass> &env)
: TGroup(p),
_last_pos(0),
_surfaces(_surfaces_storage),
_next_mat(env)
{
_surfaces.reserve(2);
add_surface(roc0, ap_radius0, thickness0, glass0);
add_surface(roc1, ap_radius1, 0, env);
}
void add_objects_for_new_grid()
{
reset_old_geometry();
add_void_maps();
add_void_contours();
if(!showOneSurface || numberOfSurfaces<1 ) add_surface();
}
TLens::TLens(const Math::VectorPair3 &p,
const QSharedPointer<TCurveBase> &curve0,
const QSharedPointer<TShapeBase> &shape0,
const QSharedPointer<TCurveBase> &curve1,
const QSharedPointer<TShapeBase> &shape1,
double thickness0,
const QSharedPointer<TGlass> &glass0,
const QSharedPointer<TGlass> &env)
: TGroup(p),
_last_pos(0),
_surfaces(_surfaces_storage),
_next_mat(env)
{
_surfaces.reserve(2);
add_surface(curve0, shape0, thickness0, glass0);
add_surface(curve1, shape1, 0, env);
}
void surface_fractal_terrain::generate_mesh(const std::vector<std::vector<double> > &height, int size, double sidelen) {
double scale = sidelen / size, delta = 1.0 / size;
std::vector<point3D> vertices;
#define __id(i, j) ((i) * (size + 1) + (j))
for (int i = 0; i <= size; ++i) {
for (int j = 0; j <= size; ++j) {
vertices.push_back(point3D(i * scale, j * scale, height[i][j]));
}
}
setup_vertex(vertices);
for (int i = 0; i < size; ++i) {
for (int j = 0; j < size; ++j) {
double u = i * delta, v = j * delta;
add_surface(__id(i, j), __id(i + 1, j), __id(i, j + 1)).set_UV(point2D(u, v), point2D(u + delta, v), point2D(u, v + delta));
add_surface(__id(i + 1, j), __id(i + 1, j + 1), __id(i, j + 1)).set_UV(point2D(u + delta, v), point2D(u + delta, v + delta), point2D(u, v + delta));
}
}
#undef __id
setup_tree();
interpolate_normal();
}
void Define_Grid()
{
free_grid_all();
/*
free_contours_all();
free_planes_mapped_all();
*/
grid = define_grid(NumPoints,limits);
if(grid)
{
if(!showOneSurface || numberOfSurfaces<1 ) add_surface();
free_iso_all();
limits.MinMax[0][3] = grid->limits.MinMax[0][3];
limits.MinMax[1][3] = grid->limits.MinMax[1][3];
}
}
void Define_Iso(gdouble isovalue)
{
free_iso_all();
set_status_label_info("IsoSurface","Computing");
/* printf("DefineIso newSUrface = %d\n",newSurface);*/
if(grid)
{
if(newSurface || numberOfSurfaces<1 )
if(!showOneSurface || numberOfSurfaces<1 ) add_surface();
newSurface = FALSE;
isopositive=define_iso_surface(grid,isovalue, grid->mapped );
if(fabs(isovalue)>1e-13)
isonegative=define_iso_surface(grid,-isovalue, grid->mapped );
if(isopositive != NULL || isonegative != NULL) set_status_label_info("IsoSurface","Ok");
}
RebuildSurf = TRUE;
}
unsigned int TLens::add_surface(double roc, double radius,
double thickness,
const QSharedPointer<TGlass> &glass)
{
TCurveBase* curve;;
if (roc == 0.)
curve = ♭
else
curve = new TSphere(roc);
TDisk* disk = new TDisk(radius);
QSharedPointer<TCurveBase> pCurve(curve);
QSharedPointer<TDisk> pDisk(disk);
return add_surface(pCurve, pDisk, thickness, glass);
}
meshmap_t Greedy::make_mesh(const Chunk& chunk)
{
meshmap_t meshes;
add_surface(chunk, meshes, surface, Plane::XY, Side::top);
add_surface(chunk, meshes, surface, Plane::XY, Side::bottom);
add_surface(chunk, meshes, surface, Plane::XZ, Side::top);
add_surface(chunk, meshes, surface, Plane::XZ, Side::bottom);
add_surface(chunk, meshes, surface, Plane::YZ, Side::top);
add_surface(chunk, meshes, surface, Plane::YZ, Side::bottom);
return meshes;
}
int set_philo_sdl_text(t_philo *philo, char *text)
{
SDL_Surface *sdl_black;
SDL_Surface *sdl_text;
sdl_black = SDL_CreateRGBSurface(0, SCREEN_WIDTH,
philo->window->fontSize + 1,
32, 0, 0, 0, 0);
if (sdl_black == NULL)
return (1);
add_surface(philo->window, sdl_black, 1,
philo->id * philo->window->fontSize + 1);
SDL_FreeSurface(sdl_black);
sdl_text = write_text(philo->window,
text, 1,
philo->id * philo->window->fontSize + 1);
SDL_FreeSurface(sdl_text);
SDL_Flip(philo->window->screen);
return (0);
}
void setup() {
set_light(50);
set_theft_handler( HOSPITAL );
set_save_file("%savedir%/%N%bed4");
/* DESCRIPTIONS */
set_orientation(%orientation%);
set_quit_handler(%out%);
set_short("bedroom");
set_base_desc( "a small bedroom" );
add_surface( "floor", "finished pine board" );
add_surface( "ceiling", "plain plaster" );
add_surface( "%0% wall", "plain plaster" );
add_surface( "%2% wall", "plain plaster" );
add_surface( "%4% wall", "plain plaster" );
add_surface( "%6% wall", "plain plaster" );
/* EXITS */
add_exit( "%4%", PATH +"%N%landing2", "door" );
modify_exit("%4%", ({ "door short", "livingroom door" }));
/* ---------------------------------------------------------------------- */
int
P_step (LDBLE step_fraction)
/* ---------------------------------------------------------------------- */
{
/*
* zero global solution, add solution or mixture, add exchange,
* add surface, add gas phase, add solid solutions,
* set temperature, and add reaction.
* Ensure all elements
* included in any of these are present in small amounts.
* Save result as n_user -1.
*/
LDBLE difftemp;
int step_number;
struct pp_assemblage *pp_assemblage_save = NULL;
struct s_s_assemblage *s_s_assemblage_save = NULL;
if (svnid == NULL)
fprintf (stderr, " ");
/*
* Zero out global solution data
*/
xsolution_zero ();
/*
* Set reaction to zero
*/
step_x = 0.0;
step_number = reaction_step;
/*
* Mixing or solution
*/
if (use.mix_ptr != NULL)
{
add_mix (use.mix_ptr);
}
else if (use.solution_ptr != NULL)
{
add_solution (use.solution_ptr, 1.0, 1.0);
}
else
{
input_error++;
error_msg ("Neither mixing nor an initial solution have "
"been defined in reaction step.", STOP);
}
/*
* Reaction
*/
if (use.irrev_ptr != NULL)
{
add_reaction (use.irrev_ptr, step_number, step_fraction);
}
/*
* Kinetics
*/
if (use.kinetics_ptr != NULL)
{
add_kinetics (use.kinetics_ptr);
/*
master_ptr =master_bsearch("S(6)");
output_msg(OUTPUT_MESSAGE,"Added kinetics, S(6) %e\n", master_ptr->total);
master_ptr =master_bsearch("S");
output_msg(OUTPUT_MESSAGE,"Added kinetics, S %e\n", master_ptr->total);
*/
}
/*
* Exchange
*/
if (use.exchange_ptr != NULL)
{
add_exchange (use.exchange_ptr);
}
/*
* Surface
*/
if (use.surface_ptr != NULL)
{
add_surface (use.surface_ptr);
}
/*
* Gases
*/
if (use.gas_phase_ptr != NULL)
{
add_gas_phase (use.gas_phase_ptr);
}
/*
* Temperature
*/
if (use.temperature_ptr != NULL)
{
add_temperature (use.temperature_ptr, step_number);
}
if ((state == TRANSPORT) && (transport_step != 0) &&
(cell > 0) && (cell != count_cells + 1))
{
difftemp = tc_x - cell_data[cell - 1].temp;
cell_data[cell - 1].temp += difftemp / tempr;
tc_x = cell_data[cell - 1].temp;
}
/*
* Pure phases and solid solutions are added to avoid
* zero or negative concentrations
*/
/*
* Pure phases
*/
if (use.pp_assemblage_ptr != NULL)
{
pp_assemblage_save =
(struct pp_assemblage *) PHRQ_malloc (sizeof (struct pp_assemblage));
if (pp_assemblage_save == NULL)
malloc_error ();
pp_assemblage_copy (use.pp_assemblage_ptr, pp_assemblage_save,
use.pp_assemblage_ptr->n_user);
add_pp_assemblage (use.pp_assemblage_ptr);
}
/*
* Solid solutions
*/
if (use.s_s_assemblage_ptr != NULL)
{
s_s_assemblage_save =
(struct s_s_assemblage *) PHRQ_malloc (sizeof (struct s_s_assemblage));
if (s_s_assemblage_save == NULL)
malloc_error ();
s_s_assemblage_copy (use.s_s_assemblage_ptr, s_s_assemblage_save,
use.s_s_assemblage_ptr->n_user);
add_s_s_assemblage (use.s_s_assemblage_ptr);
}
/*
* Check that elements are available for gas components,
* pure phases, and solid solutions
*/
if (use.gas_phase_ptr != NULL)
{
gas_phase_check (use.gas_phase_ptr);
}
if (use.pp_assemblage_ptr != NULL)
{
pp_assemblage_check (use.pp_assemblage_ptr);
}
if (use.s_s_assemblage_ptr != NULL)
{
s_s_assemblage_check (use.s_s_assemblage_ptr);
}
/*
* Check that element moles are >= zero
*/
if (solution_check () == MASS_BALANCE)
{
/* reset moles and deltas */
if (use.pp_assemblage_ptr != NULL)
{
pp_assemblage_free (use.pp_assemblage_ptr);
pp_assemblage_copy (pp_assemblage_save, use.pp_assemblage_ptr,
use.pp_assemblage_ptr->n_user);
pp_assemblage_free (pp_assemblage_save);
pp_assemblage_save =
(struct pp_assemblage *) free_check_null (pp_assemblage_save);
}
if (use.s_s_assemblage_ptr != NULL)
{
s_s_assemblage_free (use.s_s_assemblage_ptr);
s_s_assemblage_copy (s_s_assemblage_save, use.s_s_assemblage_ptr,
use.s_s_assemblage_ptr->n_user);
s_s_assemblage_free (s_s_assemblage_save);
s_s_assemblage_save =
(struct s_s_assemblage *) free_check_null (s_s_assemblage_save);
}
return (MASS_BALANCE);
}
/*
* Copy global into solution n_user = -1
*/
xsolution_save (-1);
step_save_surf (-1);
step_save_exch (-1);
/*
* Clean up temporary space
*/
if (pp_assemblage_save != NULL)
{
pp_assemblage_free (pp_assemblage_save);
pp_assemblage_save =
(struct pp_assemblage *) free_check_null (pp_assemblage_save);
}
if (s_s_assemblage_save != NULL)
{
s_s_assemblage_free (s_s_assemblage_save);
s_s_assemblage_save =
(struct s_s_assemblage *) free_check_null (s_s_assemblage_save);
}
return (OK);
}
//*******************************************
void Recpack::EMINDplate::create(const EVector& uaxis, const EVector& vaxis,
double U, double V, double W,
double flange_width, double flange_height) {
//*****************************************
const double Pi = 4*atan(1);
double t22 = tan(Pi/8.);
double s22 = 1./cos(Pi/8.);
_axis["U"] = uaxis;
_axis["V"] = vaxis;
EVector waxis = crossprod(uaxis, vaxis);
_axis["W"] = waxis;
_parameters["U"] = fabs(U);
_parameters["V"] = fabs(V);
_parameters["W"] = fabs(W);
_parameters["fw"] = flange_width;
_parameters["fh"] = flange_height;
double UU = fabs(U);
double VV = fabs(V);
double WW = fabs(W);
fw = flange_width;
fh = flange_height - UU;
EVector deltaU = uaxis*UU;
EVector deltaV = vaxis*VV;
EVector deltaW = waxis*WW;
double rt2 = sqrt(2.0);
EVector deltaS = (uaxis * (UU + VV*t22)/2. + vaxis * (VV + UU*t22)/2.);
EVector deltaT =(-uaxis * (UU + VV*t22)/2. + vaxis * (VV + UU*t22)/2.);
double SS = 0.5*sqrt((UU*UU + VV*VV)*s22*s22 - 4*UU*VV*t22);
EVector saxis = deltaS/sqrt(dot(deltaS,deltaS));
EVector taxis = deltaT/sqrt(dot(deltaT,deltaT));
EVector deltaQ = deltaS - VV/UU* fw/(rt2)*taxis;
EVector deltaR = deltaT - VV/UU* fw/(rt2)*saxis;
double QQ = sqrt(dot(deltaQ,deltaQ));
double RR = sqrt(dot(deltaR,deltaR));
EVector qaxis = 1./QQ * deltaQ;
EVector raxis = 1./RR * deltaR;
// S1 bottom
add_surface("outer", new Rectangle(_position-deltaV,vaxis,waxis,WW,t22*VV + UU/2.));
// S2 top
add_surface("outer", new Rectangle(_position+deltaV,vaxis,waxis,WW,t22*VV + UU/2.));
// S3 bottom-side -
add_surface("outer", new Rectangle(_position-deltaS,saxis,waxis,WW,t22*VV));
// S4 bottom-side +
add_surface("outer", new Rectangle(_position-deltaT,taxis,waxis,WW,t22*VV));
// S5 top-side +
add_surface("outer", new Rectangle(_position+deltaQ,qaxis,taxis,
t22*VV + fw/rt2, WW));
// S6 top-side -
add_surface("outer", new Rectangle(_position+deltaR,raxis,saxis,
t22*VV + fw/rt2, WW));
// S7 side -
add_surface("outer", new Rectangle(_position-deltaU-vaxis*(t22*UU-fh)/2.,
uaxis,vaxis,(t22*VV + fh)/2.0,WW));
// S8 side +
add_surface("outer", new Rectangle(_position+deltaU-vaxis*(t22*UU-fh)/2.,
uaxis,vaxis,(t22*VV + fh)/2.0,WW));
// S9 back
add_surface("outer", new MINDsection(_position-deltaW,waxis,uaxis,UU,VV,fw,fh));
// S10 front
add_surface("outer", new MINDsection(_position+deltaW,waxis,uaxis,UU,VV,fw,fh));
// S11 flange tip +
add_surface("outer", new Rectangle(_position+ uaxis*(UU + fw) +
vaxis*0.5*(VV*t22 - fw + fh),
uaxis, vaxis,0.5*(VV*t22 - fw - fh),
WW));
// S12 flange tip -
add_surface("outer", new Rectangle(_position- uaxis*(UU + fw) +
vaxis*0.5*(VV*t22 - fw + fh),
uaxis, vaxis,0.5*(VV*t22 - fw - fh),
WW));
// S13 flange bottom +
add_surface("outer", new Rectangle(_position + uaxis*(UU + fw/2.) +
vaxis*fh, vaxis, uaxis, fw/2., WW));
// S13 flange bottom -
add_surface("outer", new Rectangle(_position - uaxis*(UU + fw/2.) +
vaxis*fh, vaxis, uaxis, fw/2., WW));
// _size = uaxis*(UU + fw) + vaxis*VV + waxis*WW;
}
bool ArrayMesh::_set(const StringName &p_name, const Variant &p_value) {
String sname = p_name;
if (p_name == "blend_shape/names") {
PoolVector<String> sk = p_value;
int sz = sk.size();
PoolVector<String>::Read r = sk.read();
for (int i = 0; i < sz; i++)
add_blend_shape(r[i]);
return true;
}
if (p_name == "blend_shape/mode") {
set_blend_shape_mode(BlendShapeMode(int(p_value)));
return true;
}
if (sname.begins_with("surface_")) {
int sl = sname.find("/");
if (sl == -1)
return false;
int idx = sname.substr(8, sl - 8).to_int() - 1;
String what = sname.get_slicec('/', 1);
if (what == "material")
surface_set_material(idx, p_value);
else if (what == "name")
surface_set_name(idx, p_value);
return true;
}
if (!sname.begins_with("surfaces"))
return false;
int idx = sname.get_slicec('/', 1).to_int();
String what = sname.get_slicec('/', 2);
if (idx == surfaces.size()) {
//create
Dictionary d = p_value;
ERR_FAIL_COND_V(!d.has("primitive"), false);
if (d.has("arrays")) {
//old format
ERR_FAIL_COND_V(!d.has("morph_arrays"), false);
add_surface_from_arrays(PrimitiveType(int(d["primitive"])), d["arrays"], d["morph_arrays"]);
} else if (d.has("array_data")) {
PoolVector<uint8_t> array_data = d["array_data"];
PoolVector<uint8_t> array_index_data;
if (d.has("array_index_data"))
array_index_data = d["array_index_data"];
ERR_FAIL_COND_V(!d.has("format"), false);
uint32_t format = d["format"];
uint32_t primitive = d["primitive"];
ERR_FAIL_COND_V(!d.has("vertex_count"), false);
int vertex_count = d["vertex_count"];
int index_count = 0;
if (d.has("index_count"))
index_count = d["index_count"];
Vector<PoolVector<uint8_t> > blend_shapes;
if (d.has("blend_shape_data")) {
Array blend_shape_data = d["blend_shape_data"];
for (int i = 0; i < blend_shape_data.size(); i++) {
PoolVector<uint8_t> shape = blend_shape_data[i];
blend_shapes.push_back(shape);
}
}
ERR_FAIL_COND_V(!d.has("aabb"), false);
AABB aabb = d["aabb"];
Vector<AABB> bone_aabb;
if (d.has("skeleton_aabb")) {
Array baabb = d["skeleton_aabb"];
bone_aabb.resize(baabb.size());
for (int i = 0; i < baabb.size(); i++) {
bone_aabb[i] = baabb[i];
}
}
add_surface(format, PrimitiveType(primitive), array_data, vertex_count, array_index_data, index_count, aabb, blend_shapes, bone_aabb);
} else {
ERR_FAIL_V(false);
}
if (d.has("material")) {
surface_set_material(idx, d["material"]);
}
if (d.has("name")) {
surface_set_name(idx, d["name"]);
}
return true;
}
return false;
}
int main ( int argc, char** argv )
{
std::cout << "Starting\n";
initalize();
//TODO add resource load error handling
add_surface("spaceb", load_surface("gray_space.png",1) );
add_surface("spacem", load_surface("gray_space.png",1) );
add_surface("spacef", load_surface("gray_space.png",1) );
for(int i=-2; i < 20+2; i++)
meta::objects.push_back(new psrect_static(200*i, 200, 200, 200));
//meta::objects.push_back(new psrect_static(320, 20, 320, 20));
//meta::objects.push_back(new psrect_static(0, -400,1, 1000));
//meta::objects.push_back(new psrect_static(1000, -400, 1, 1000));
meta::objects.push_back(new rocket(2000,-100, 50,70));
//load_map("test.json");
float32 timeStep = 1.0f / 30.0f;
int32 velocityIterations = 6;
int32 positionIterations = 2;
FPSmanager manager;
SDL_initFramerate(&manager);
SDL_setFramerate(&manager, 30);
// program main loop
bool done = false;
while (!done)
{
SDL_framerateDelay(&manager);
// message processing loop
SDL_Event event;
while (SDL_PollEvent(&event))
{
// check for messages
switch (event.type)
{
// exit if the window is closed
case SDL_QUIT:
done = true;
break;
// check for keypresses
case SDL_KEYDOWN:
// exit if ESCAPE is pressed
if (event.key.keysym.sym == SDLK_ESCAPE)
done = true;
break;
} // end switch
} // end of message processing
// DRAWING STARTS HERE
// clear screen
//SDL_FillRect(meta::screen, 0, SDL_MapRGB(meta::screen->format, 0, 0, 0 ));
SDL_FillRect(meta::screen, 0, SDL_MapRGB(meta::screen->format, meta::background_red , meta::background_green, meta::background_blue ));
draw_background();
// Instruct the world to perform a single step of simulation.
// It is generally best to keep the time step and iterations fixed.
meta::world.Step(timeStep, velocityIterations, positionIterations);
update_objects();
meta::world.DrawDebugData();
// DRAWING ENDS HERE
// finally, update the screen :)
SDL_Flip(meta::screen);
} // end main loop
// all is well ;)
printf("Exited cleanly\n");
return 0;
}
bool Mesh::_set(const StringName& p_name, const Variant& p_value) {
String sname=p_name;
if (p_name=="morph_target/names") {
DVector<String> sk=p_value;
int sz = sk.size();
DVector<String>::Read r = sk.read();
for(int i=0;i<sz;i++)
add_morph_target(r[i]);
return true;
}
if (p_name=="morph_target/mode") {
set_morph_target_mode(MorphTargetMode(int(p_value)));
return true;
}
if (sname.begins_with("surface_")) {
int sl=sname.find("/");
if (sl==-1)
return false;
int idx=sname.substr(8,sl-8).to_int()-1;
String what = sname.get_slice("/",1);
if (what=="material")
surface_set_material(idx,p_value);
else if (what=="name")
surface_set_name(idx,p_value);
return true;
}
if (sname=="custom_aabb/custom_aabb") {
set_custom_aabb(p_value);
return true;
}
if (!sname.begins_with("surfaces"))
return false;
int idx=sname.get_slice("/",1).to_int();
String what=sname.get_slice("/",2);
if (idx==surfaces.size()) {
if (what=="custom") {
add_custom_surface(p_value);
return true;
}
//create
Dictionary d=p_value;
ERR_FAIL_COND_V(!d.has("primitive"),false);
ERR_FAIL_COND_V(!d.has("arrays"),false);
ERR_FAIL_COND_V(!d.has("morph_arrays"),false);
bool alphasort = d.has("alphasort") && bool(d["alphasort"]);
add_surface(PrimitiveType(int(d["primitive"])),d["arrays"],d["morph_arrays"],alphasort);
if (d.has("material")) {
surface_set_material(idx,d["material"]);
}
if (d.has("name")) {
surface_set_name(idx,d["name"]);
}
return true;
}
if (what=="custom_aabb") {
surface_set_custom_aabb(idx,p_value);
return true;
}
return false;
}
