caiyu/three.cad
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

working wasm connection

Browse Source
This commit is contained in:
howard 2021-03-21 03:42:14 -07:00
parent f3f04f9cfb
commit ec59e95b87
12 changed files with 4424 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
dist/CDemo.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

BIN
dist/CDemo.wasm vendored Executable file
View File

Binary file not shown.

1358
dist/bundle.js vendored
View File

File diff suppressed because one or more lines are too long

3
dist/index.html vendored
View File

@ -61,7 +61,8 @@
<div id="view2"></div>
</div>
<script src="solver.js">
</script>
<script src="bundle.js" type="module"></script>
</script>

2353
dist/solver.js vendored Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
dist/solver.wasm vendored Executable file
View File

Binary file not shown.

33
src/Sketcher.js
View File

@ -1,5 +1,6 @@
import { Matrix4 } from 'three';
import * as THREE from '../node_modules/three/src/Three'
export class Sketcher extends THREE.Group {
@ -53,11 +54,6 @@ export class Sketcher extends THREE.Group {
this.mode = ""
this.keyTable = {
'l': this.addLine,
'Escape': this.clear
}
}
@ -84,6 +80,9 @@ export class Sketcher extends THREE.Group {
this.addLine()
this.mode = "line"
break;
case 'b':
this.writeBuff()
break;
case '=':
this.plane.applyMatrix4(new Matrix4().makeRotationY(0.1))
this.orientSketcher()
@ -142,7 +141,7 @@ export class Sketcher extends THREE.Group {
grabbedMove(e) {
const mouseLoc = this.getLocation(e);
this.moveLinePt(this.grabPtIdx,mouseLoc)
this.moveLinePt(this.grabPtIdx, mouseLoc)
this.dispatchEvent({ type: 'change' })
}
@ -259,7 +258,29 @@ export class Sketcher extends THREE.Group {
this.pointStart(e)
}
writeBuff() {
// const linesBuf = new Float32Array(this.linesArr.length * 4)
// const xyOnly = [0,1,3,4];
// let p = 0
// for (let i = 0; i < this.linesArr.length; i++) {
// for (let j of xyOnly) {
// linesBuf[p++] = this.linesArr[i].geometry.attributes.position.array[j]
// }
// }
let ptsBuf = new Float32Array(this.ptsArr.length * 2)
for (let i = 0, p = 0; i < this.ptsArr.length; i++) {
for (let j = 0; j < 2; j++) {
ptsBuf[p++] = this.ptsArr[i].geometry.attributes.position.array[j]
}
}
console.log(ptsBuf)
buffer = Module._malloc(ptsBuf.length * ptsBuf.BYTES_PER_ELEMENT)
Module.HEAPF32.set(ptsBuf, buffer >> 2)
Module["_solver"](buffer)
}
}

1
src/scratch.js Normal file
View File

@ -0,0 +1 @@

BIN
wasm/libslvs.a Normal file
View File

Binary file not shown.

1
wasm/notes Normal file
View File

@ -0,0 +1 @@
emcc ./wasm/solver.c ./wasm/libslvs.a -L./wasm/ -lslvs -o ./dist/solver.js -s TOTAL_MEMORY=134217728 -s EXPORTED_FUNCTIONS='[_main, _solver]'

404
wasm/slvs.h Normal file
View File

@ -0,0 +1,404 @@
/*-----------------------------------------------------------------------------
* Data structures and prototypes for slvs.lib, a geometric constraint solver.
*
* See the comments in this file, the accompanying sample code that uses
* this library, and the accompanying documentation (DOC.txt).
*
* Copyright 2009-2013 Jonathan Westhues.
*---------------------------------------------------------------------------*/
#ifndef __SLVS_H
#define __SLVS_H
#ifdef WIN32
# ifdef EXPORT_DLL
# define DLL __declspec( dllexport )
# else
# define DLL __declspec( dllimport )
# endif
#else
# define DLL
#endif
#ifdef __cplusplus
extern "C" {
#endif
#ifdef _MSC_VER
typedef unsigned __int32 uint32_t;
#else
#include <stdint.h>
#endif
typedef uint32_t Slvs_hParam;
typedef uint32_t Slvs_hEntity;
typedef uint32_t Slvs_hConstraint;
typedef uint32_t Slvs_hGroup;
/* To obtain the 3d (not projected into a workplane) of a constraint or
* an entity, specify this instead of the workplane. */
#define SLVS_FREE_IN_3D 0
typedef struct {
Slvs_hParam h;
Slvs_hGroup group;
double val;
} Slvs_Param;
#define SLVS_E_POINT_IN_3D 50000
#define SLVS_E_POINT_IN_2D 50001
#define SLVS_E_NORMAL_IN_3D 60000
#define SLVS_E_NORMAL_IN_2D 60001
#define SLVS_E_DISTANCE 70000
/* The special point, normal, and distance types used for parametric step
* and repeat, extrude, and assembly are currently not exposed. Please
* contact us if you are interested in using these. */
#define SLVS_E_WORKPLANE 80000
#define SLVS_E_LINE_SEGMENT 80001
#define SLVS_E_CUBIC 80002
#define SLVS_E_CIRCLE 80003
#define SLVS_E_ARC_OF_CIRCLE 80004
typedef struct {
Slvs_hEntity h;
Slvs_hGroup group;
int type;
Slvs_hEntity wrkpl;
Slvs_hEntity point[4];
Slvs_hEntity normal;
Slvs_hEntity distance;
Slvs_hParam param[4];
} Slvs_Entity;
#define SLVS_C_POINTS_COINCIDENT 100000
#define SLVS_C_PT_PT_DISTANCE 100001
#define SLVS_C_PT_PLANE_DISTANCE 100002
#define SLVS_C_PT_LINE_DISTANCE 100003
#define SLVS_C_PT_FACE_DISTANCE 100004
#define SLVS_C_PT_IN_PLANE 100005
#define SLVS_C_PT_ON_LINE 100006
#define SLVS_C_PT_ON_FACE 100007
#define SLVS_C_EQUAL_LENGTH_LINES 100008
#define SLVS_C_LENGTH_RATIO 100009
#define SLVS_C_EQ_LEN_PT_LINE_D 100010
#define SLVS_C_EQ_PT_LN_DISTANCES 100011
#define SLVS_C_EQUAL_ANGLE 100012
#define SLVS_C_EQUAL_LINE_ARC_LEN 100013
#define SLVS_C_SYMMETRIC 100014
#define SLVS_C_SYMMETRIC_HORIZ 100015
#define SLVS_C_SYMMETRIC_VERT 100016
#define SLVS_C_SYMMETRIC_LINE 100017
#define SLVS_C_AT_MIDPOINT 100018
#define SLVS_C_HORIZONTAL 100019
#define SLVS_C_VERTICAL 100020
#define SLVS_C_DIAMETER 100021
#define SLVS_C_PT_ON_CIRCLE 100022
#define SLVS_C_SAME_ORIENTATION 100023
#define SLVS_C_ANGLE 100024
#define SLVS_C_PARALLEL 100025
#define SLVS_C_PERPENDICULAR 100026
#define SLVS_C_ARC_LINE_TANGENT 100027
#define SLVS_C_CUBIC_LINE_TANGENT 100028
#define SLVS_C_EQUAL_RADIUS 100029
#define SLVS_C_PROJ_PT_DISTANCE 100030
#define SLVS_C_WHERE_DRAGGED 100031
#define SLVS_C_CURVE_CURVE_TANGENT 100032
#define SLVS_C_LENGTH_DIFFERENCE 100033
typedef struct {
Slvs_hConstraint h;
Slvs_hGroup group;
int type;
Slvs_hEntity wrkpl;
double valA;
Slvs_hEntity ptA;
Slvs_hEntity ptB;
Slvs_hEntity entityA;
Slvs_hEntity entityB;
Slvs_hEntity entityC;
Slvs_hEntity entityD;
int other;
int other2;
} Slvs_Constraint;
typedef struct {
/*** INPUT VARIABLES
*
* Here, we specify the parameters and their initial values, the entities,
* and the constraints. For example, param[] points to the array of
* parameters, which has length params, so that the last valid element
* is param[params-1].
*
* param[] is actually an in/out variable; if the solver is successful,
* then the new values (that satisfy the constraints) are written to it. */
Slvs_Param *param;
int params;
Slvs_Entity *entity;
int entities;
Slvs_Constraint *constraint;
int constraints;
/* If a parameter corresponds to a point (distance, normal, etc.) being
* dragged, then specify it here. This will cause the solver to favor
* that parameter, and attempt to change it as little as possible even
* if that requires it to change other parameters more.
*
* Unused members of this array should be set to zero. */
Slvs_hParam dragged[4];
/* If the solver fails, then it can determine which constraints are
* causing the problem. But this is a relatively slow process (for
* a system with n constraints, about n times as long as just solving).
* If calculateFaileds is true, then the solver will do so, otherwise
* not. */
int calculateFaileds;
/*** OUTPUT VARIABLES
*
* If the solver fails, then it can report which constraints are causing
* the problem. The caller should allocate the array failed[], and pass
* its size in faileds.
*
* The solver will set faileds equal to the number of problematic
* constraints, and write their Slvs_hConstraints into failed[]. To
* ensure that there is sufficient space for any possible set of
* failing constraints, faileds should be greater than or equal to
* constraints. */
Slvs_hConstraint *failed;
int faileds;
/* The solver indicates the number of unconstrained degrees of freedom. */
int dof;
/* The solver indicates whether the solution succeeded. */
#define SLVS_RESULT_OKAY 0
#define SLVS_RESULT_INCONSISTENT 1
#define SLVS_RESULT_DIDNT_CONVERGE 2
#define SLVS_RESULT_TOO_MANY_UNKNOWNS 3
int result;
} Slvs_System;
DLL void Slvs_Solve(Slvs_System *sys, Slvs_hGroup hg);
/* Our base coordinate system has basis vectors
* (1, 0, 0) (0, 1, 0) (0, 0, 1)
* A unit quaternion defines a rotation to a new coordinate system with
* basis vectors
* U V N
* which these functions compute from the quaternion. */
DLL void Slvs_QuaternionU(double qw, double qx, double qy, double qz,
double *x, double *y, double *z);
DLL void Slvs_QuaternionV(double qw, double qx, double qy, double qz,
double *x, double *y, double *z);
DLL void Slvs_QuaternionN(double qw, double qx, double qy, double qz,
double *x, double *y, double *z);
/* Similarly, compute a unit quaternion in terms of two basis vectors. */
DLL void Slvs_MakeQuaternion(double ux, double uy, double uz,
double vx, double vy, double vz,
double *qw, double *qx, double *qy, double *qz);
/*-------------------------------------
* These are just convenience functions, to save you the trouble of filling
* out the structures by hand. The code is included in the header file to
* let the compiler inline them if possible. */
static inline Slvs_Param Slvs_MakeParam(Slvs_hParam h, Slvs_hGroup group, double val)
{
Slvs_Param r;
r.h = h;
r.group = group;
r.val = val;
return r;
}
static inline Slvs_Entity Slvs_MakePoint2d(Slvs_hEntity h, Slvs_hGroup group,
Slvs_hEntity wrkpl,
Slvs_hParam u, Slvs_hParam v)
{
Slvs_Entity r;
memset(&r, 0, sizeof(r));
r.h = h;
r.group = group;
r.type = SLVS_E_POINT_IN_2D;
r.wrkpl = wrkpl;
r.param[0] = u;
r.param[1] = v;
return r;
}
static inline Slvs_Entity Slvs_MakePoint3d(Slvs_hEntity h, Slvs_hGroup group,
Slvs_hParam x, Slvs_hParam y, Slvs_hParam z)
{
Slvs_Entity r;
memset(&r, 0, sizeof(r));
r.h = h;
r.group = group;
r.type = SLVS_E_POINT_IN_3D;
r.wrkpl = SLVS_FREE_IN_3D;
r.param[0] = x;
r.param[1] = y;
r.param[2] = z;
return r;
}
static inline Slvs_Entity Slvs_MakeNormal3d(Slvs_hEntity h, Slvs_hGroup group,
Slvs_hParam qw, Slvs_hParam qx,
Slvs_hParam qy, Slvs_hParam qz)
{
Slvs_Entity r;
memset(&r, 0, sizeof(r));
r.h = h;
r.group = group;
r.type = SLVS_E_NORMAL_IN_3D;
r.wrkpl = SLVS_FREE_IN_3D;
r.param[0] = qw;
r.param[1] = qx;
r.param[2] = qy;
r.param[3] = qz;
return r;
}
static inline Slvs_Entity Slvs_MakeNormal2d(Slvs_hEntity h, Slvs_hGroup group,
Slvs_hEntity wrkpl)
{
Slvs_Entity r;
memset(&r, 0, sizeof(r));
r.h = h;
r.group = group;
r.type = SLVS_E_NORMAL_IN_2D;
r.wrkpl = wrkpl;
return r;
}
static inline Slvs_Entity Slvs_MakeDistance(Slvs_hEntity h, Slvs_hGroup group,
Slvs_hEntity wrkpl, Slvs_hParam d)
{
Slvs_Entity r;
memset(&r, 0, sizeof(r));
r.h = h;
r.group = group;
r.type = SLVS_E_DISTANCE;
r.wrkpl = wrkpl;
r.param[0] = d;
return r;
}
static inline Slvs_Entity Slvs_MakeLineSegment(Slvs_hEntity h, Slvs_hGroup group,
Slvs_hEntity wrkpl,
Slvs_hEntity ptA, Slvs_hEntity ptB)
{
Slvs_Entity r;
memset(&r, 0, sizeof(r));
r.h = h;
r.group = group;
r.type = SLVS_E_LINE_SEGMENT;
r.wrkpl = wrkpl;
r.point[0] = ptA;
r.point[1] = ptB;
return r;
}
static inline Slvs_Entity Slvs_MakeCubic(Slvs_hEntity h, Slvs_hGroup group,
Slvs_hEntity wrkpl,
Slvs_hEntity pt0, Slvs_hEntity pt1,
Slvs_hEntity pt2, Slvs_hEntity pt3)
{
Slvs_Entity r;
memset(&r, 0, sizeof(r));
r.h = h;
r.group = group;
r.type = SLVS_E_CUBIC;
r.wrkpl = wrkpl;
r.point[0] = pt0;
r.point[1] = pt1;
r.point[2] = pt2;
r.point[3] = pt3;
return r;
}
static inline Slvs_Entity Slvs_MakeArcOfCircle(Slvs_hEntity h, Slvs_hGroup group,
Slvs_hEntity wrkpl,
Slvs_hEntity normal,
Slvs_hEntity center,
Slvs_hEntity start, Slvs_hEntity end)
{
Slvs_Entity r;
memset(&r, 0, sizeof(r));
r.h = h;
r.group = group;
r.type = SLVS_E_ARC_OF_CIRCLE;
r.wrkpl = wrkpl;
r.normal = normal;
r.point[0] = center;
r.point[1] = start;
r.point[2] = end;
return r;
}
static inline Slvs_Entity Slvs_MakeCircle(Slvs_hEntity h, Slvs_hGroup group,
Slvs_hEntity wrkpl,
Slvs_hEntity center,
Slvs_hEntity normal, Slvs_hEntity radius)
{
Slvs_Entity r;
memset(&r, 0, sizeof(r));
r.h = h;
r.group = group;
r.type = SLVS_E_CIRCLE;
r.wrkpl = wrkpl;
r.point[0] = center;
r.normal = normal;
r.distance = radius;
return r;
}
static inline Slvs_Entity Slvs_MakeWorkplane(Slvs_hEntity h, Slvs_hGroup group,
Slvs_hEntity origin, Slvs_hEntity normal)
{
Slvs_Entity r;
memset(&r, 0, sizeof(r));
r.h = h;
r.group = group;
r.type = SLVS_E_WORKPLANE;
r.wrkpl = SLVS_FREE_IN_3D;
r.point[0] = origin;
r.normal = normal;
return r;
}
static inline Slvs_Constraint Slvs_MakeConstraint(Slvs_hConstraint h,
Slvs_hGroup group,
int type,
Slvs_hEntity wrkpl,
double valA,
Slvs_hEntity ptA,
Slvs_hEntity ptB,
Slvs_hEntity entityA,
Slvs_hEntity entityB)
{
Slvs_Constraint r;
memset(&r, 0, sizeof(r));
r.h = h;
r.group = group;
r.type = type;
r.wrkpl = wrkpl;
r.valA = valA;
r.ptA = ptA;
r.ptB = ptB;
r.entityA = entityA;
r.entityB = entityB;
return r;
}
#ifdef __cplusplus
}
#endif
#endif

281
wasm/solver.c Normal file
View File

@ -0,0 +1,281 @@
/*-----------------------------------------------------------------------------
* Some sample code for slvs.dll. We draw some geometric entities, provide
* initial guesses for their positions, and then constrain them. The solver
* calculates their new positions, in order to satisfy the constraints.
*
* Copyright 2008-2013 Jonathan Westhues.
*---------------------------------------------------------------------------*/
#ifdef WIN32
# include <windows.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include "slvs.h"
static Slvs_System sys;
static void *CheckMalloc(size_t n)
{
void *r = malloc(n);
if(!r) {
printf("out of memory!\n");
exit(-1);
}
return r;
}
/*-----------------------------------------------------------------------------
* An example of a constraint in 3d. We create a single group, with some
* entities and constraints.
*---------------------------------------------------------------------------*/
void Example3d()
{
/* This will contain a single group, which will arbitrarily number 1. */
Slvs_hGroup g = 1;
/* A point, initially at (x y z) = (10 10 10) */
sys.param[sys.params++] = Slvs_MakeParam(1, g, 10.0);
sys.param[sys.params++] = Slvs_MakeParam(2, g, 10.0);
sys.param[sys.params++] = Slvs_MakeParam(3, g, 10.0);
sys.entity[sys.entities++] = Slvs_MakePoint3d(101, g, 1, 2, 3);
/* and a second point at (20 20 20) */
sys.param[sys.params++] = Slvs_MakeParam(4, g, 20.0);
sys.param[sys.params++] = Slvs_MakeParam(5, g, 20.0);
sys.param[sys.params++] = Slvs_MakeParam(6, g, 20.0);
sys.entity[sys.entities++] = Slvs_MakePoint3d(102, g, 4, 5, 6);
/* and a line segment connecting them. */
sys.entity[sys.entities++] = Slvs_MakeLineSegment(200, g,
SLVS_FREE_IN_3D, 101, 102);
/* The distance between the points should be 30.0 units. */
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
1, g,
SLVS_C_PT_PT_DISTANCE,
SLVS_FREE_IN_3D,
30.0,
101, 102, 0, 0);
/* Let's tell the solver to keep the second point as close to constant
* as possible, instead moving the first point. */
sys.dragged[0] = 4;
sys.dragged[1] = 5;
sys.dragged[2] = 6;
/* Now that we have written our system, we solve. */
Slvs_Solve(&sys, g);
if(sys.result == SLVS_RESULT_OKAY) {
printf("okay; now at (%.3f %.3f %.3f)\n"
" (%.3f %.3f %.3f)\n",
sys.param[0].val, sys.param[1].val, sys.param[2].val,
sys.param[3].val, sys.param[4].val, sys.param[5].val);
printf("%d DOF\n", sys.dof);
} else {
printf("solve failed");
}
}
/*-----------------------------------------------------------------------------
* An example of a constraint in 2d. In our first group, we create a workplane
* along the reference frame's xy plane. In a second group, we create some
* entities in that group and dimension them.
*---------------------------------------------------------------------------*/
void Example2d(float xx)
{
Slvs_hGroup g;
double qw, qx, qy, qz;
g = 1;
/* First, we create our workplane. Its origin corresponds to the origin
* of our base frame (x y z) = (0 0 0) */
sys.param[sys.params++] = Slvs_MakeParam(1, g, 0.0);
sys.param[sys.params++] = Slvs_MakeParam(2, g, 0.0);
sys.param[sys.params++] = Slvs_MakeParam(3, g, 0.0);
sys.entity[sys.entities++] = Slvs_MakePoint3d(101, g, 1, 2, 3);
/* and it is parallel to the xy plane, so it has basis vectors (1 0 0)
* and (0 1 0). */
Slvs_MakeQuaternion(1, 0, 0,
0, 1, 0, &qw, &qx, &qy, &qz);
sys.param[sys.params++] = Slvs_MakeParam(4, g, qw);
sys.param[sys.params++] = Slvs_MakeParam(5, g, qx);
sys.param[sys.params++] = Slvs_MakeParam(6, g, qy);
sys.param[sys.params++] = Slvs_MakeParam(7, g, qz);
sys.entity[sys.entities++] = Slvs_MakeNormal3d(102, g, 4, 5, 6, 7);
sys.entity[sys.entities++] = Slvs_MakeWorkplane(200, g, 101, 102);
/* Now create a second group. We'll solve group 2, while leaving group 1
* constant; so the workplane that we've created will be locked down,
* and the solver can't move it. */
g = 2;
/* These points are represented by their coordinates (u v) within the
* workplane, so they need only two parameters each. */
sys.param[sys.params++] = Slvs_MakeParam(11, g, 10.0);
sys.param[sys.params++] = Slvs_MakeParam(12, g, 20.0);
sys.entity[sys.entities++] = Slvs_MakePoint2d(301, g, 200, 11, 12);
sys.param[sys.params++] = Slvs_MakeParam(13, g, 20.0);
sys.param[sys.params++] = Slvs_MakeParam(14, g, 10.0);
sys.entity[sys.entities++] = Slvs_MakePoint2d(302, g, 200, 13, 14);
/* And we create a line segment with those endpoints. */
sys.entity[sys.entities++] = Slvs_MakeLineSegment(400, g,
200, 301, 302);
/* Now three more points. */
sys.param[sys.params++] = Slvs_MakeParam(15, g, 110.0);
sys.param[sys.params++] = Slvs_MakeParam(16, g, 120.0);
sys.entity[sys.entities++] = Slvs_MakePoint2d(303, g, 200, 15, 16);
sys.param[sys.params++] = Slvs_MakeParam(17, g, 120.0);
sys.param[sys.params++] = Slvs_MakeParam(18, g, 110.0);
sys.entity[sys.entities++] = Slvs_MakePoint2d(304, g, 200, 17, 18);
sys.param[sys.params++] = Slvs_MakeParam(19, g, 115.0);
sys.param[sys.params++] = Slvs_MakeParam(20, g, xx);
sys.entity[sys.entities++] = Slvs_MakePoint2d(305, g, 200, 19, 20);
/* And arc, centered at point 303, starting at point 304, ending at
* point 305. */
sys.entity[sys.entities++] = Slvs_MakeArcOfCircle(401, g, 200, 102,
303, 304, 305);
/* Now one more point, and a distance */
sys.param[sys.params++] = Slvs_MakeParam(21, g, 200.0);
sys.param[sys.params++] = Slvs_MakeParam(22, g, 200.0);
sys.entity[sys.entities++] = Slvs_MakePoint2d(306, g, 200, 21, 22);
sys.param[sys.params++] = Slvs_MakeParam(23, g, 30.0);
sys.entity[sys.entities++] = Slvs_MakeDistance(307, g, 200, 23);
/* And a complete circle, centered at point 306 with radius equal to
* distance 307. The normal is 102, the same as our workplane. */
sys.entity[sys.entities++] = Slvs_MakeCircle(402, g, 200,
306, 102, 307);
/* The length of our line segment is 30.0 units. */
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
1, g,
SLVS_C_PT_PT_DISTANCE,
200,
30.0,
301, 302, 0, 0);
/* And the distance from our line segment to the origin is 10.0 units. */
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
2, g,
SLVS_C_PT_LINE_DISTANCE,
200,
10.0,
101, 0, 400, 0);
/* And the line segment is vertical. */
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
3, g,
SLVS_C_VERTICAL,
200,
0.0,
0, 0, 400, 0);
/* And the distance from one endpoint to the origin is 15.0 units. */
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
4, g,
SLVS_C_PT_PT_DISTANCE,
200,
15.0,
301, 101, 0, 0);
#if 0
/* And same for the other endpoint; so if you add this constraint then
* the sketch is overconstrained and will signal an error. */
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
5, g,
SLVS_C_PT_PT_DISTANCE,
200,
18.0,
302, 101, 0, 0);
#endif /* 0 */
/* The arc and the circle have equal radius. */
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
6, g,
SLVS_C_EQUAL_RADIUS,
200,
0.0,
0, 0, 401, 402);
/* The arc has radius 17.0 units. */
sys.constraint[sys.constraints++] = Slvs_MakeConstraint(
7, g,
SLVS_C_DIAMETER,
200,
17.0*2,
0, 0, 401, 0);
/* If the solver fails, then ask it to report which constraints caused
* the problem. */
sys.calculateFaileds = 1;
/* And solve. */
Slvs_Solve(&sys, g);
if(sys.result == SLVS_RESULT_OKAY) {
printf("solved okay\n");
printf("line from (%.3f %.3f) to (%.3f %.3f)\n",
sys.param[7].val, sys.param[8].val,
sys.param[9].val, sys.param[10].val);
printf("arc center (%.3f %.3f) start (%.3f %.3f) finish (%.3f %.3f)\n",
sys.param[11].val, sys.param[12].val,
sys.param[13].val, sys.param[14].val,
sys.param[15].val, sys.param[16].val);
printf("circle center (%.3f %.3f) radius %.3f\n",
sys.param[17].val, sys.param[18].val,
sys.param[19].val);
printf("%d DOF\n", sys.dof);
} else {
int i;
printf("solve failed: problematic constraints are:");
for(i = 0; i < sys.faileds; i++) {
printf(" %d", sys.failed[i]);
}
printf("\n");
if(sys.result == SLVS_RESULT_INCONSISTENT) {
printf("system inconsistent\n");
} else {
printf("system nonconvergent\n");
}
}
}
int solver(float *ptr)
{
// Example2d(150.0);
// sys.params = sys.constraints = sys.entities = 0;
for (int i=0; i<10 ;i++) {
printf("%f\n",*ptr++);
}
return 0;
}
int main(int argc, char *argv[])
{
sys.param = CheckMalloc(50*sizeof(sys.param[0]));
sys.entity = CheckMalloc(50*sizeof(sys.entity[0]));
sys.constraint = CheckMalloc(50*sizeof(sys.constraint[0]));
sys.failed = CheckMalloc(50*sizeof(sys.failed[0]));
sys.faileds = 50;
// Example2d(150.0);
printf("hello\n");
return 0;
}