static void
print_ahstats(const struct ahstat *ahstat)
{
#define p32(f, m) if (ahstat->f || sflag <= 1) \
printf("\t%u" m, (unsigned int)ahstat->f, plural(ahstat->f))
#define p64(f, m) if (ahstat->f || sflag <= 1) \
printf("\t%ju" m, (uintmax_t)ahstat->f, plural(ahstat->f))
#define hist(f, n, t) \
ipsec_hist_new((f), sizeof(f)/sizeof(f[0]), (n), (t));
p32(ahs_hdrops, " packet%s shorter than header shows\n");
p32(ahs_nopf, " packet%s dropped; protocol family not supported\n");
p32(ahs_notdb, " packet%s dropped; no TDB\n");
p32(ahs_badkcr, " packet%s dropped; bad KCR\n");
p32(ahs_qfull, " packet%s dropped; queue full\n");
p32(ahs_noxform, " packet%s dropped; no transform\n");
p32(ahs_wrap, " replay counter wrap%s\n");
p32(ahs_badauth, " packet%s dropped; bad authentication detected\n");
p32(ahs_badauthl, " packet%s dropped; bad authentication length\n");
p32(ahs_replay, " possible replay packet%s detected\n");
p32(ahs_input, " packet%s in\n");
p32(ahs_output, " packet%s out\n");
p32(ahs_invalid, " packet%s dropped; invalid TDB\n");
p64(ahs_ibytes, " byte%s in\n");
p64(ahs_obytes, " byte%s out\n");
p32(ahs_toobig, " packet%s dropped; larger than IP_MAXPACKET\n");
p32(ahs_pdrops, " packet%s blocked due to policy\n");
p32(ahs_crypto, " crypto processing failure%s\n");
p32(ahs_tunnel, " tunnel sanity check failure%s\n");
hist(ahstat->ahs_hist, ipsec_ahnames, "AH output");
#undef p32
#undef p64
#undef hist
}
void _stdcall xts_serpent_sse2_decrypt(const unsigned char *in, unsigned char *out, size_t len, u64 offset, xts_key *key)
#endif
{
__m128i t0, t1, t2, t3;
__m128i b0, b1, b2, b3;
__m128i idx;
int i;
p64(&idx)[0] = offset / XTS_SECTOR_SIZE;
p64(&idx)[1] = 0;
do
{
/* update tweak unit index */
p64(&idx)[0]++;
/* derive first tweak value */
serpent256_encrypt(pv(&idx), pv(&t0), &key->tweak_k.serpent);
for (i = 0; i < XTS_BLOCKS_IN_SECTOR / 4; i++)
{
/* derive t1-t3 */
sse2_next_tweak(t1, t0);
sse2_next_tweak(t2, t1);
sse2_next_tweak(t3, t2);
/* load and tweak 4 blocks */
b0 = _mm_xor_si128(_mm_loadu_si128(p128(in + 0 )), t0);
b1 = _mm_xor_si128(_mm_loadu_si128(p128(in + 16)), t1);
b2 = _mm_xor_si128(_mm_loadu_si128(p128(in + 32)), t2);
b3 = _mm_xor_si128(_mm_loadu_si128(p128(in + 48)), t3);
/* encrypt / decrypt */
serpent256_sse2_decrypt(b0, b1, b2, b3, &key->crypt_k.serpent);
/* tweak and store 4 blocks */
_mm_storeu_si128(p128(out + 0 ), _mm_xor_si128(b0, t0));
_mm_storeu_si128(p128(out + 16), _mm_xor_si128(b1, t1));
_mm_storeu_si128(p128(out + 32), _mm_xor_si128(b2, t2));
_mm_storeu_si128(p128(out + 48), _mm_xor_si128(b3, t3));
/* derive next t0 */
sse2_next_tweak(t0, t3);
/* update pointers */
in += XTS_BLOCK_SIZE*4; out += XTS_BLOCK_SIZE*4;
}
} while (len -= XTS_SECTOR_SIZE);
}
static void
print_ipcompstats(const struct ipcompstat *ipcompstat)
{
uint32_t version;
#define p32(f, m) if (ipcompstat->f || sflag <= 1) \
printf("\t%u" m, (unsigned int)ipcompstat->f, plural(ipcompstat->f))
#define p64(f, m) if (ipcompstat->f || sflag <= 1) \
printf("\t%ju" m, (uintmax_t)ipcompstat->f, plural(ipcompstat->f))
#define hist(f, n, t) \
ipsec_hist_new((f), sizeof(f)/sizeof(f[0]), (n), (t));
#ifndef IPCOMPSTAT_VERSION
version = 0;
#else
version = ipcompstat->version;
#endif
p32(ipcomps_hdrops, " packet%s shorter than header shows\n");
p32(ipcomps_nopf, " packet%s dropped; protocol family not supported\n");
p32(ipcomps_notdb, " packet%s dropped; no TDB\n");
p32(ipcomps_badkcr, " packet%s dropped; bad KCR\n");
p32(ipcomps_qfull, " packet%s dropped; queue full\n");
p32(ipcomps_noxform, " packet%s dropped; no transform\n");
p32(ipcomps_wrap, " replay counter wrap%s\n");
p32(ipcomps_input, " packet%s in\n");
p32(ipcomps_output, " packet%s out\n");
p32(ipcomps_invalid, " packet%s dropped; invalid TDB\n");
p64(ipcomps_ibytes, " byte%s in\n");
p64(ipcomps_obytes, " byte%s out\n");
p32(ipcomps_toobig, " packet%s dropped; larger than IP_MAXPACKET\n");
p32(ipcomps_pdrops, " packet%s blocked due to policy\n");
p32(ipcomps_crypto, " crypto processing failure%s\n");
hist(ipcompstat->ipcomps_hist, ipsec_compnames, "COMP output");
if (version >= 1) {
p32(ipcomps_threshold, " packet%s sent uncompressed; size < compr. algo. threshold\n");
p32(ipcomps_uncompr, " packet%s sent uncompressed; compression was useless\n");
}
#undef p32
#undef p64
#undef hist
}
/**
Terminate the hash to get the digest
*/
void _stdcall sha512_done(sha512_ctx *ctx, unsigned char *out)
{
int i;
/* increase the length of the message */
ctx->length += ctx->curlen * 8;
/* append the '1' bit */
ctx->buf[ctx->curlen++] = 0x80;
/* if the length is currently above 112 bytes we append zeros
* then compress. Then we can fall back to padding zeros and length
* encoding like normal.
*/
if (ctx->curlen > 112)
{
while (ctx->curlen < SHA512_BLOCK_SIZE) {
ctx->buf[ctx->curlen++] = 0;
}
sha512_compress(ctx, ctx->buf);
ctx->curlen = 0;
}
/* pad upto 120 bytes of zeroes
* note: that from 112 to 120 is the 64 MSB of the length. We assume that you won't hash
* > 2^64 bits of data... :-)
*/
while (ctx->curlen < 120) {
ctx->buf[ctx->curlen++] = 0;
}
/* store length */
p64(ctx->buf)[15] = BE64(ctx->length);
sha512_compress(ctx, ctx->buf);
/* copy output */
for (i = 0; i < 8; i++) {
p64(out)[i] = BE64(ctx->hash[i]);
}
}
/* compress 1024-bits */
static void sha512_compress(sha512_ctx *ctx, const unsigned char *buf)
{
u64 S[8], W[80], t0, t1;
int i;
/* copy state into S */
memcpy(S, ctx->hash, sizeof(S));
/* copy the state into 1024-bits into W[0..15] */
for (i = 0; i < 16; i++) {
W[i] = BE64(p64(buf)[i]);
}
/* fill W[16..79] */
for (i = 16; i < 80; i++) {
W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
}
/* Compress */
#define RND(a,b,c,d,e,f,g,h,i) \
t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \
t1 = Sigma0(a) + Maj(a, b, c); \
d += t0; \
h = t0 + t1;
for (i = 0; i < 80; i += 8) {
RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],i+0);
RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],i+1);
RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],i+2);
RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],i+3);
RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],i+4);
RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],i+5);
RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],i+6);
RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],i+7);
}
ctx->hash[0] += S[0]; ctx->hash[1] += S[1];
ctx->hash[2] += S[2]; ctx->hash[3] += S[3];
ctx->hash[4] += S[4]; ctx->hash[5] += S[5];
ctx->hash[6] += S[6]; ctx->hash[7] += S[7];
/* prevent leaks */
burn(&S, sizeof(S));
burn(&W, sizeof(W));
}
/*
* Dump IGMP statistics structure.
*/
void
igmp_stats(u_long off, const char *name, int af1 __unused, int proto __unused)
{
struct igmpstat igmpstat;
if (fetch_stats("net.inet.igmp.stats", 0, &igmpstat,
sizeof(igmpstat), kread) != 0)
return;
if (igmpstat.igps_version != IGPS_VERSION_3) {
xo_warnx("%s: version mismatch (%d != %d)", __func__,
igmpstat.igps_version, IGPS_VERSION_3);
}
if (igmpstat.igps_len != IGPS_VERSION3_LEN) {
xo_warnx("%s: size mismatch (%d != %d)", __func__,
igmpstat.igps_len, IGPS_VERSION3_LEN);
}
xo_open_container(name);
xo_emit("{T:/%s}:\n", name);
#define p64(f, m) if (igmpstat.f || sflag <= 1) \
xo_emit(m, (uintmax_t) igmpstat.f, plural(igmpstat.f))
#define py64(f, m) if (igmpstat.f || sflag <= 1) \
xo_emit(m, (uintmax_t) igmpstat.f, pluralies(igmpstat.f))
p64(igps_rcv_total, "\t{:received-messages/%ju} "
"{N:/message%s received}\n");
p64(igps_rcv_tooshort, "\t{:dropped-too-short/%ju} "
"{N:/message%s received with too few bytes}\n");
p64(igps_rcv_badttl, "\t{:dropped-wrong-ttl/%ju} "
"{N:/message%s received with wrong TTL}\n");
p64(igps_rcv_badsum, "\t{:dropped-bad-checksum/%ju} "
"{N:/message%s received with bad checksum}\n");
py64(igps_rcv_v1v2_queries, "\t{:received-membership-queries/%ju} "
"{N:/V1\\/V2 membership quer%s received}\n");
py64(igps_rcv_v3_queries, "\t{:received-v3-membership-queries/%ju} "
"{N:/V3 membership quer%s received}\n");
py64(igps_rcv_badqueries, "\t{:dropped-membership-queries/%ju} "
"{N:/membership quer%s received with invalid field(s)}\n");
py64(igps_rcv_gen_queries, "\t{:received-general-queries/%ju} "
"{N:/general quer%s received}\n");
py64(igps_rcv_group_queries, "\t{:received-group-queries/%ju} "
"{N:/group quer%s received}\n");
py64(igps_rcv_gsr_queries, "\t{:received-group-source-queries/%ju} "
"{N:/group-source quer%s received}\n");
py64(igps_drop_gsr_queries, "\t{:dropped-group-source-queries/%ju} "
"{N:/group-source quer%s dropped}\n");
p64(igps_rcv_reports, "\t{:received-membership-requests/%ju} "
"{N:/membership report%s received}\n");
p64(igps_rcv_badreports, "\t{:dropped-membership-reports/%ju} "
"{N:/membership report%s received with invalid field(s)}\n");
p64(igps_rcv_ourreports, "\t"
"{:received-membership-reports-matching/%ju} "
"{N:/membership report%s received for groups to which we belong}"
"\n");
p64(igps_rcv_nora, "\t{:received-v3-reports-no-router-alert/%ju} "
"{N:/V3 report%s received without Router Alert}\n");
p64(igps_snd_reports, "\t{:sent-membership-reports/%ju} "
"{N:/membership report%s sent}\n");
#undef p64
#undef py64
xo_close_container(name);
}
int main(int argc, char** argv)
{
// parse command
unsigned int pos = 1;
unsigned int mask = (argc >= 2) ? 0 : 0xFFFF;
while(pos < argc)
{
unsigned int sceneNumber = atoi(argv[pos++]);
mask |= 1 << sceneNumber;
}
// Initialize
phong p32(32.0f);
phong p64(64.0f);
phong p16(16.0f);
diffuse d;
constantAlbedo red(color(1.0f, 0.0f, 0.0f));
constantAlbedo green(color(0.0f, 1.0f, 0.0f));
constantAlbedo blue(color(0.0f, 0.0f, 1.0f));
constantAlbedo white(color(1.0f, 1.0f, 1.0f));
std::vector<triangle> sphere = createSphere( vec3d(0.0f, 0.0f, 0.0f), 1.0f, 16, 16 );
std::vector<triangle> plane = createPlane( vec3d(-1.0f, -1.0f, 0.0f), vec3d(0.0f, 2.0f, 0.0f), vec3d(2.0f, 0.0f, 0.0f) );
material redMaterial;
redMaterial.addComponent( reflectanceComponent(&red, &d) );
redMaterial.addComponent( reflectanceComponent(&white, &p32) );
material greenMaterial;
greenMaterial.addComponent( reflectanceComponent(&green, &d) );
greenMaterial.addComponent( reflectanceComponent(&white, &p64) );
material blueMaterial;
blueMaterial.addComponent( reflectanceComponent(&blue, &d) );
blueMaterial.addComponent( reflectanceComponent(&white, &p16) );
material whiteMaterial;
whiteMaterial.addComponent( reflectanceComponent(&white, &d) );
triangleMesh redSphere(sphere, redMaterial);
triangleMesh greenSphere(sphere, greenMaterial);
triangleMesh blueSphere(sphere, blueMaterial);
triangleMesh whitePlane(plane, whiteMaterial);
sceneGraphObject redSphereObject(redSphere);
sceneGraphObject greenSphereObject(greenSphere);
sceneGraphObject blueSphereObject(blueSphere);
sceneGraphObject whitePlaneObject(whitePlane);
camera cam( vec3d(0.0f, 0.0f, 5.0f),
vec3d(0.0f, 0.0f, -1.0f),
vec3d(0.0f, 1.0f, 0.0f),
35.0f * M_PI / 180.0f,
512, 512 );
directionalLightsource ls( color(1.0f, 1.0f, 1.0f), vec3d(0.0f, -1.0f, -1.0f) );
directionalLightsource frontal( color(1.0f, 1.0f, 1.0f), vec3d(0.0f, 0.0f, -1.0f) );
/////////////////////////////////////////////////////
if((mask & 2) != 0)
{
sceneGraphNode sg1;
sg1.addChildNode(redSphereObject);
std::cout << "Generating Image 1." << std::endl;
image result1 = generateImage(cam, sg1, ls);
result1.save("hw4-result1.ppm");
}
/////////////////////////////////////////////////////
if((mask & 4) != 0)
{
sceneGraphNode sg2node1(translation3d(vec3d(+1.0f, 0.0f, 0.0f)));
sg2node1.addChildNode(redSphereObject);
sceneGraphNode sg2node2(translation3d(vec3d(-1.0f, 0.0f, 0.0f)));
sg2node2.addChildNode(blueSphereObject);
sceneGraphNode sg2;
sg2.addChildNode(sg2node1);
sg2.addChildNode(sg2node2);
std::cout << "Generating Image 2." << std::endl;
image result2 = generateImage(cam, sg2, ls);
result2.save("hw4-result2.ppm");
}
/////////////////////////////////////////////////////
if((mask & 8) != 0)
{
sceneGraphNode sg3node1(scale3d(2.0f, 0.5f, 0.5f));
sg3node1.addChildNode(greenSphereObject);
sceneGraphNode sg3;
sg3.addChildNode(sg3node1);
std::cout << "Generating Image 3." << std::endl;
image result3 = generateImage(cam, sg3, ls);
result3.save("hw4-result3.ppm");
}
/////////////////////////////////////////////////////
if((mask & 16) != 0)
{
sceneGraphNode sg2node1(translation3d(vec3d(+1.0f, 0.0f, 0.0f)));
sg2node1.addChildNode(redSphereObject);
sceneGraphNode sg2node2(translation3d(vec3d(-1.0f, 0.0f, 0.0f)));
sg2node2.addChildNode(blueSphereObject);
sceneGraphNode sg2;
sg2.addChildNode(sg2node1);
sg2.addChildNode(sg2node2);
sceneGraphNode sg4node1(rotationY3d(M_PI));
sg4node1.addChildNode(sg2);
sceneGraphNode sg4;
sg4.addChildNode(sg4node1);
std::cout << "Generating Image 4." << std::endl;
image result4 = generateImage(cam, sg4, ls);
result4.save("hw4-result4.ppm");
}
/////////////////////////////////////////////////////
if((mask & 32) != 0)
{
sceneGraphNode sg5node0(scale3d(0.5f, 0.5f, 0.5f));
sceneGraphNode sg5node1(rotationY3d(0.5 * M_PI));
sceneGraphNode sg5node2(rotationX3d(0.5 * M_PI));
sceneGraphNode sg5node3(translation3d(vec3d(0.0f, 2.0f, 0.0f)));
sceneGraphNode sg5node4(rotationX3d(0.5 * M_PI));
sceneGraphNode sg5node5(translation3d(vec3d(0.0f, 2.0f, 0.0f)));
sceneGraphNode sg5node6(rotationX3d(0.5 * M_PI));
sceneGraphNode sg5node7(translation3d(vec3d(0.0f, 2.0f, 0.0f)));
sceneGraphNode sg5node8(rotationX3d(0.5 * M_PI));
sceneGraphNode sg5node9(translation3d(vec3d(0.0f, 2.0f, 0.0f)));
sceneGraphNode sg5;
sg5.addChildNode(sg5node0);
sg5node0.addChildNode(sg5node1);
sg5node1.addChildNode(sg5node2);
sg5node2.addChildNode(sg5node3);
sg5node3.addChildNode(redSphereObject);
sg5node3.addChildNode(sg5node4);
sg5node4.addChildNode(sg5node5);
sg5node5.addChildNode(greenSphereObject);
sg5node5.addChildNode(sg5node6);
sg5node6.addChildNode(sg5node7);
sg5node7.addChildNode(blueSphereObject);
sg5node7.addChildNode(sg5node8);
sg5node8.addChildNode(sg5node9);
sg5node9.addChildNode(blueSphereObject);
std::cout << "Generating Image 5." << std::endl;
image result5 = generateImage(cam, sg5, ls);
result5.save("hw4-result5.ppm");
}
/////////////////////////////////////////////////////
if((mask & 64) != 0)
{
sceneGraphNode cubeside( translation3d(vec3d(0.0f, 0.0f, 1.0f)) );
cubeside.addChildNode(whitePlaneObject);
sceneGraphNode cubeNode1( rotationY3d(0.0f / 2.0f * M_PI) );
cubeNode1.addChildNode(cubeside);
sceneGraphNode cubeNode2( rotationY3d(1.0f / 2.0f * M_PI) );
cubeNode2.addChildNode(cubeside);
sceneGraphNode cubeNode3( rotationY3d(2.0f / 2.0f * M_PI) );
cubeNode3.addChildNode(cubeside);
sceneGraphNode cubeNode4( rotationY3d(3.0f / 2.0f * M_PI) );
cubeNode4.addChildNode(cubeside);
sceneGraphNode cubeNode5( rotationX3d(0.5f * M_PI) );
cubeNode5.addChildNode(cubeside);
sceneGraphNode cubeNode6( rotationX3d(-0.5f * M_PI) );
cubeNode6.addChildNode(cubeside);
sceneGraphNode cube;
cube.addChildNode(cubeNode1);
cube.addChildNode(cubeNode2);
cube.addChildNode(cubeNode3);
cube.addChildNode(cubeNode4);
cube.addChildNode(cubeNode5);
cube.addChildNode(cubeNode6);
sceneGraphNode sg6( rotation3d(0.25*M_PI, vec3d(1.0f, 0.75f, 0.5f)) );
sg6.addChildNode(cube);
std::cout << "Generating Image 6." << std::endl;
image result6 = generateImage(cam, sg6, frontal);
result6.save("hw4-result6.ppm");
}
// Done.
return 0;
}
int main(int argc, char* argv[])
{
CS325Graphics window(argc, argv);
float delta = 0.1;
Point2D p1(CS325Graphics::X_MIN, CS325Graphics::Y_MAX / 4.5);
Point2D p2(CS325Graphics::X_MAX, CS325Graphics::Y_MAX / 4.5);
Point2D p3(CS325Graphics::X_MIN, CS325Graphics::Y_MIN);
Point2D p4(CS325Graphics::X_MAX, CS325Graphics::Y_MAX);
//Points 41, 42, 45, 46 control the sandbox. DON"T MESS WITH THEM!
Point3D p30(0.5, 0.5,-3.5);
Point3D p31(0.5, -0.5,-3.5);
Point3D p32(-0.5,-0.5,-3.5);
Point3D p33(-0.5, 0.5,-3.5);
Point3D p34(0.5, 0.5,-1.5);
Point3D p35(0.5, -0.5,-1.5);
Point3D p36(-0.5,-0.5,-1.5);
Point3D p37(-0.5, 0.5,-1.5);
Point3D p40( -70.8, 28.8, -50.8);
Point3D p41( 50.8,-2.8, 50.8);
Point3D p42(-50.8,-2.8, 50.8);
Point3D p43(-58.8, 25.8, 50.8);
Point3D p44( 50.8, 50.8, -50.8);
Point3D p45( 50.8,-2.8, -50.8);
Point3D p46(-50.8,-2.8, -50.8);
Point3D p47(-84.8,-2.8, -50.8);
Point3D p49(-8.5,22.0, 50.8);
Point3D p48(70,20,50.8);
Point3D p50(3.5, 0.5,-3.5);
Point3D p51(3.5, -0.5,-3.5);
Point3D p52(2.5,-0.5,-3.5);
Point3D p53(2.5, 0.5,-3.5);
Point3D p54(3.5, 0.5,-1.5);
Point3D p55(3.5, -0.5,-1.5);
Point3D p56(2.5,-0.5,-1.5);
Point3D p57(2.5, 0.5,-1.5);
Point3D p60(3.5, 0.5, 13.5);
Point3D p61(3.5, -0.5, 13.5);
Point3D p62(2.5,-0.5, 13.5);
Point3D p63(2.5, 0.5, 13.5);
Point3D p64(3.5, 0.5, 16.5);
Point3D p65(3.5, -0.5, 16.5);
Point3D p66(2.5,-0.5, 16.5);
Point3D p67(2.5, 0.5, 16.5);
Point2D viewPos;
Vector2D viewDir;
Vector3D deltaV;
viewDir.setAngle(0);
// move view position
for(int i = 0; i < MOVE_TEST; i){
/*window.DrawLineOnScreen(p1, p2);*/
//window.DrawLineOnScreen(p4, p3);
window.DrawLineInSpace(p30, p31);
window.DrawLineInSpace(p31, p32);
window.DrawLineInSpace(p32, p33);
window.DrawLineInSpace(p33, p30);
window.DrawLineInSpace(p34, p35);
window.DrawLineInSpace(p35, p36);
window.DrawLineInSpace(p36, p37);
window.DrawLineInSpace(p37, p34);
window.DrawLineInSpace(p30, p34);
window.DrawLineInSpace(p31, p35);
window.DrawLineInSpace(p32, p36);
window.DrawLineInSpace(p33, p37);
window.DrawLineInSpace(p50, p51);
window.DrawLineInSpace(p51, p52);
window.DrawLineInSpace(p52, p53);
window.DrawLineInSpace(p53, p50);
window.DrawLineInSpace(p54, p55);
window.DrawLineInSpace(p55, p56);
window.DrawLineInSpace(p56, p57);
window.DrawLineInSpace(p57, p54);
window.DrawLineInSpace(p50, p54);
window.DrawLineInSpace(p51, p55);
window.DrawLineInSpace(p52, p56);
window.DrawLineInSpace(p53, p57);
window.DrawLineInSpace(p60, p61);
window.DrawLineInSpace(p61, p62);
window.DrawLineInSpace(p62, p63);
window.DrawLineInSpace(p63, p60);
window.DrawLineInSpace(p64, p65);
window.DrawLineInSpace(p65, p66);
window.DrawLineInSpace(p66, p67);
window.DrawLineInSpace(p67, p64);
window.DrawLineInSpace(p60, p64);
window.DrawLineInSpace(p61, p65);
window.DrawLineInSpace(p62, p66);
window.DrawLineInSpace(p63, p67);
//window.DrawLineInSpace(p40, p41);
window.DrawLineInSpace(p41, p42);
window.DrawLineInSpace(p42, p43);
//window.DrawLineInSpace(p43, p40);
//window.DrawLineInSpace(p44, p45);
window.DrawLineInSpace(p45, p46);
//window.DrawLineInSpace(p46, p47);
//window.DrawLineInSpace(p47, p44);
window.DrawLineInSpace(p40, p45);
window.DrawLineInSpace(p41, p45);
window.DrawLineInSpace(p42, p46);
window.DrawLineInSpace(p43, p47);
window.DrawLineInSpace(p40, p47);
window.DrawLineInSpace(p41, p49);
window.DrawLineInSpace(p42, p49);
window.DrawLineInSpace(p41, p48);
window.DrawLineInSpace(p45, p48);
if(GetAsyncKeyState(VK_DOWN)) // the DOWN arrow was pressed, let's do something
{
delta = -.1;
viewPos.setY(viewPos.getY() + cos(-viewDir.getAngle())*delta);
viewPos.setX(viewPos.getX() + sin(-viewDir.getAngle())*delta);
window.SetViewPosition(viewPos);
cout << "view pos: " << viewPos.toString() << endl;
window.DisplayNow();
Sleep(50);
}
if(GetAsyncKeyState(VK_UP)) // the UP arrow was pressed, let's do something
{
delta = .1;
viewPos.setY(viewPos.getY() + cos(-viewDir.getAngle())*delta);
viewPos.setX(viewPos.getX() + sin(-viewDir.getAngle())*delta);
window.SetViewPosition(viewPos);
cout << "view pos: " << viewPos.toString() << endl;
window.DisplayNow();
Sleep(50);
}
if(GetAsyncKeyState(VK_RIGHT)) // the RIGHT arrow was pressed, let's do something
{
delta = .1;
viewDir.setAngle(viewDir.getAngle()+delta);
window.SetViewDirection(viewDir);
cout << "view dir: " << viewDir.getAngle() << endl;
window.DisplayNow();
Sleep(50);
}
if(GetAsyncKeyState(VK_LEFT)) // the LEFT arrow was pressed, let's do something
{
delta = -.1;
viewDir.setAngle(viewDir.getAngle()+delta);
window.SetViewDirection(viewDir);
cout << "view dir: " << viewDir.getAngle() << endl;
window.DisplayNow();
Sleep(50);
}
if(GetAsyncKeyState(VK_ESCAPE))
{
return 1;
}
}
}
