From 38bf774214a848d4ed57c648428ee54d9e825d98 Mon Sep 17 00:00:00 2001 From: Scott Duensing Date: Sun, 25 Aug 2019 17:56:21 -0500 Subject: [PATCH] Initial commit. Before switching to stretchy_buffer from utarray. --- .gitignore | 2 + cube.obj | 48 ++++++++++ j3d.pro | 15 ++++ main.c | 136 +++++++++++++++++++++++++++++ postlink.sh | 7 ++ utarray.h | 247 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 455 insertions(+) create mode 100644 .gitignore create mode 100644 cube.obj create mode 100644 j3d.pro create mode 100644 main.c create mode 100755 postlink.sh create mode 100644 utarray.h diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9a585f6 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +*.user +*.~ diff --git a/cube.obj b/cube.obj new file mode 100644 index 0000000..be7902d --- /dev/null +++ b/cube.obj @@ -0,0 +1,48 @@ +# Blender3D v249 OBJ File: untitled.blend +# www.blender3d.org +mtllib cube.mtl +v 1.000000 -1.000000 -1.000000 +v 1.000000 -1.000000 1.000000 +v -1.000000 -1.000000 1.000000 +v -1.000000 -1.000000 -1.000000 +v 1.000000 1.000000 -1.000000 +v 0.999999 1.000000 1.000001 +v -1.000000 1.000000 1.000000 +v -1.000000 1.000000 -1.000000 +vt 0.748573 0.750412 +vt 0.749279 0.501284 +vt 0.999110 0.501077 +vt 0.999455 0.750380 +vt 0.250471 0.500702 +vt 0.249682 0.749677 +vt 0.001085 0.750380 +vt 0.001517 0.499994 +vt 0.499422 0.500239 +vt 0.500149 0.750166 +vt 0.748355 0.998230 +vt 0.500193 0.998728 +vt 0.498993 0.250415 +vt 0.748953 0.250920 +vn 0.000000 0.000000 -1.000000 +vn -1.000000 -0.000000 -0.000000 +vn -0.000000 -0.000000 1.000000 +vn -0.000001 0.000000 1.000000 +vn 1.000000 -0.000000 0.000000 +vn 1.000000 0.000000 0.000001 +vn 0.000000 1.000000 -0.000000 +vn -0.000000 -1.000000 0.000000 +usemtl Material_ray.png +s off +f 5/1/1 1/2/1 4/3/1 +f 5/1/1 4/3/1 8/4/1 +f 3/5/2 7/6/2 8/7/2 +f 3/5/2 8/7/2 4/8/2 +f 2/9/3 6/10/3 3/5/3 +f 6/10/4 7/6/4 3/5/4 +f 1/2/5 5/1/5 2/9/5 +f 5/1/6 6/10/6 2/9/6 +f 5/1/7 8/11/7 6/10/7 +f 8/11/7 7/12/7 6/10/7 +f 1/2/8 2/9/8 3/13/8 +f 1/2/8 3/13/8 4/14/8 + diff --git a/j3d.pro b/j3d.pro new file mode 100644 index 0000000..91c74bc --- /dev/null +++ b/j3d.pro @@ -0,0 +1,15 @@ +JOEY = /home/scott/joey +include($$JOEY/dist/joey.pri) + +HEADERS += \ + utarray.h + +SOURCES += \ + main.c + +OTHER_FILES += \ + postlink.sh \ + notes.txt \ + cube.obj + +linux:QMAKE_POST_LINK = $$PWD/postlink.sh "$$PWD" "$$JOEY" diff --git a/main.c b/main.c new file mode 100644 index 0000000..070e4f8 --- /dev/null +++ b/main.c @@ -0,0 +1,136 @@ +#include +#include + +#include "utarray.h" + +#define JOEY_MAIN +#include "joey.h" +#ifdef JOEY_IIGS +segment "j3d"; +#endif + +#pragma GCC diagnostic push +//#pragma GCC diagnostic ignored "-Wcast-align" + +typedef struct { + float x; + float y; + float z; +} j3VertexT; + +typedef struct { + j3VertexT local[3]; + j3VertexT world[3]; + j3VertexT camera[3]; +} j3TriangleT; + +typedef struct { + UT_array *verticies; + UT_array *triangles; +} j3ObjectT; + +typedef struct { + UT_array *objects; +} j3WorldT; + + +static UT_icd j3VertexT_icd = { sizeof(j3VertexT), NULL, NULL, NULL }; +static UT_icd j3TriangleT_icd = { sizeof(j3TriangleT), NULL, NULL, NULL }; +static UT_icd j3WorldT_icd = { sizeof(j3WorldT), NULL, NULL, NULL }; + + +bool j3WorldLoad(char *file, j3WorldT *world); + + +bool j3WorldLoad(char *file, j3WorldT *world) { + int r; + int x; + char token[1024]; + char *c; + FILE *in; + j3VertexT *vp; + j3VertexT v; + j3ObjectT o; + j3TriangleT t; + + in = fopen(jlUtilMakePathname(file, "obj"), "rt"); + + // Did we find the file? + if (in == NULL) { + // Nope. + return false; + } + + // Initialize object array inside world object + utarray_new(world->objects, &j3WorldT_icd); + + // Create an initial object to read data into (***TODO*** support multiple objects) + utarray_new(o.verticies, &j3VertexT_icd); + utarray_new(o.triangles, &j3TriangleT_icd); + + while (true) { + + // Read next token + r = fscanf(in, "%s", token); + //printf("fscanf s = %d [%s]\n", r, token); + + // End of file? + if (r == EOF) { + break; + } + + // Vertex? + if (strcmp(token, "v" ) == 0) { + r = fscanf(in, "%f %f %f\n", &v.x, &v.y, &v.z); + //printf("fscanf f f f = %d [%s]\n", r, token); + //printf("Vertex: %f %f %f\n", v.x, v.y, v.z); + utarray_push_back(o.verticies, &v); + } + + // Face? + if (strcmp(token, "f" ) == 0) { + //printf("Triangle:\n"); + for (x=0; x<3; x++) { + // Fetch 'x'th vertex index + r = fscanf(in, "%s", token); + //printf("fscanf s = %d [%s]\n", r, token); + c = strstr(token, "/"); + if (c) c[0] = 0; + r = atoi(token); + //printf("atoi = %d\n", r); + vp = (j3VertexT *)utarray_eltptr(o.verticies, (unsigned int)r - 1); + t.local[x] = *vp; + //printf(" Face Index: %s Vertex: %f %f %f\n", token, vp->x, vp->y, vp->z); + } + fscanf(in, "\n"); + utarray_push_back(o.triangles, &t); + } + } + + // Finished! Clean up. + fclose(in); + + return true; +} + + +int main(void) { + + j3WorldT world; + j3ObjectT *object; + + jlUtilStartup("JoeyLib 3D"); + + j3WorldLoad("cube", &world); + + printf("Made it here\n"); + + object = (j3ObjectT *)utarray_front(world.objects); + printf("Verticies: %d\n", utarray_len(object->verticies)); + printf("Triangles: %d\n", utarray_len(object->triangles)); + + jlKeyWaitForAny(); + jlUtilShutdown(); +} + +#pragma GCC diagnostic pop diff --git a/postlink.sh b/postlink.sh new file mode 100755 index 0000000..4f92893 --- /dev/null +++ b/postlink.sh @@ -0,0 +1,7 @@ +#!/bin/bash + +GAME=$1 +export JOEY=$2 + +mkdir -p data +cp -f "${GAME}"/*.obj data/. diff --git a/utarray.h b/utarray.h new file mode 100644 index 0000000..cc20614 --- /dev/null +++ b/utarray.h @@ -0,0 +1,247 @@ +/* +Copyright (c) 2008-2018, Troy D. Hanson http://troydhanson.github.com/uthash/ +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER +OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/* a dynamic array implementation using macros + */ +#ifndef UTARRAY_H +#define UTARRAY_H + +#define UTARRAY_VERSION 2.1.0 + +#include /* size_t */ +#include /* memset, etc */ +#include /* exit */ + +#ifdef __GNUC__ +#define UTARRAY_UNUSED __attribute__((__unused__)) +#else +#define UTARRAY_UNUSED +#endif + +#ifdef oom +#error "The name of macro 'oom' has been changed to 'utarray_oom'. Please update your code." +#define utarray_oom() oom() +#endif + +#ifndef utarray_oom +#define utarray_oom() exit(-1) +#endif + +typedef void (ctor_f)(void *dst, const void *src); +typedef void (dtor_f)(void *elt); +typedef void (init_f)(void *elt); +typedef struct { + size_t sz; + init_f *init; + ctor_f *copy; + dtor_f *dtor; +} UT_icd; + +typedef struct { + unsigned i,n;/* i: index of next available slot, n: num slots */ + UT_icd icd; /* initializer, copy and destructor functions */ + char *d; /* n slots of size icd->sz*/ +} UT_array; + +#define utarray_init(a,_icd) do { \ + memset(a,0,sizeof(UT_array)); \ + (a)->icd = *(_icd); \ +} while(0) + +#define utarray_done(a) do { \ + if ((a)->n) { \ + if ((a)->icd.dtor) { \ + unsigned _ut_i; \ + for(_ut_i=0; _ut_i < (a)->i; _ut_i++) { \ + (a)->icd.dtor(utarray_eltptr(a,_ut_i)); \ + } \ + } \ + free((a)->d); \ + } \ + (a)->n=0; \ +} while(0) + +#define utarray_new(a,_icd) do { \ + (a) = (UT_array*)malloc(sizeof(UT_array)); \ + if ((a) == NULL) { \ + utarray_oom(); \ + } \ + utarray_init(a,_icd); \ +} while(0) + +#define utarray_free(a) do { \ + utarray_done(a); \ + free(a); \ +} while(0) + +#define utarray_reserve(a,by) do { \ + if (((a)->i+(by)) > (a)->n) { \ + char *utarray_tmp; \ + while (((a)->i+(by)) > (a)->n) { (a)->n = ((a)->n ? (2*(a)->n) : 8); } \ + utarray_tmp=(char*)realloc((a)->d, (a)->n*(a)->icd.sz); \ + if (utarray_tmp == NULL) { \ + utarray_oom(); \ + } \ + (a)->d=utarray_tmp; \ + } \ +} while(0) + +#define utarray_push_back(a,p) do { \ + utarray_reserve(a,1); \ + if ((a)->icd.copy) { (a)->icd.copy( _utarray_eltptr(a,(a)->i++), p); } \ + else { memcpy(_utarray_eltptr(a,(a)->i++), p, (a)->icd.sz); }; \ +} while(0) + +#define utarray_pop_back(a) do { \ + if ((a)->icd.dtor) { (a)->icd.dtor( _utarray_eltptr(a,--((a)->i))); } \ + else { (a)->i--; } \ +} while(0) + +#define utarray_extend_back(a) do { \ + utarray_reserve(a,1); \ + if ((a)->icd.init) { (a)->icd.init(_utarray_eltptr(a,(a)->i)); } \ + else { memset(_utarray_eltptr(a,(a)->i),0,(a)->icd.sz); } \ + (a)->i++; \ +} while(0) + +#define utarray_len(a) ((a)->i) + +#define utarray_eltptr(a,j) (((j) < (a)->i) ? _utarray_eltptr(a,j) : NULL) +#define _utarray_eltptr(a,j) ((a)->d + ((a)->icd.sz * (j))) + +#define utarray_insert(a,p,j) do { \ + if ((j) > (a)->i) utarray_resize(a,j); \ + utarray_reserve(a,1); \ + if ((j) < (a)->i) { \ + memmove( _utarray_eltptr(a,(j)+1), _utarray_eltptr(a,j), \ + ((a)->i - (j))*((a)->icd.sz)); \ + } \ + if ((a)->icd.copy) { (a)->icd.copy( _utarray_eltptr(a,j), p); } \ + else { memcpy(_utarray_eltptr(a,j), p, (a)->icd.sz); }; \ + (a)->i++; \ +} while(0) + +#define utarray_inserta(a,w,j) do { \ + if (utarray_len(w) == 0) break; \ + if ((j) > (a)->i) utarray_resize(a,j); \ + utarray_reserve(a,utarray_len(w)); \ + if ((j) < (a)->i) { \ + memmove(_utarray_eltptr(a,(j)+utarray_len(w)), \ + _utarray_eltptr(a,j), \ + ((a)->i - (j))*((a)->icd.sz)); \ + } \ + if ((a)->icd.copy) { \ + unsigned _ut_i; \ + for(_ut_i=0;_ut_i<(w)->i;_ut_i++) { \ + (a)->icd.copy(_utarray_eltptr(a, (j) + _ut_i), _utarray_eltptr(w, _ut_i)); \ + } \ + } else { \ + memcpy(_utarray_eltptr(a,j), _utarray_eltptr(w,0), \ + utarray_len(w)*((a)->icd.sz)); \ + } \ + (a)->i += utarray_len(w); \ +} while(0) + +#define utarray_resize(dst,num) do { \ + unsigned _ut_i; \ + if ((dst)->i > (unsigned)(num)) { \ + if ((dst)->icd.dtor) { \ + for (_ut_i = (num); _ut_i < (dst)->i; ++_ut_i) { \ + (dst)->icd.dtor(_utarray_eltptr(dst, _ut_i)); \ + } \ + } \ + } else if ((dst)->i < (unsigned)(num)) { \ + utarray_reserve(dst, (num) - (dst)->i); \ + if ((dst)->icd.init) { \ + for (_ut_i = (dst)->i; _ut_i < (unsigned)(num); ++_ut_i) { \ + (dst)->icd.init(_utarray_eltptr(dst, _ut_i)); \ + } \ + } else { \ + memset(_utarray_eltptr(dst, (dst)->i), 0, (dst)->icd.sz*((num) - (dst)->i)); \ + } \ + } \ + (dst)->i = (num); \ +} while(0) + +#define utarray_concat(dst,src) do { \ + utarray_inserta(dst, src, utarray_len(dst)); \ +} while(0) + +#define utarray_erase(a,pos,len) do { \ + if ((a)->icd.dtor) { \ + unsigned _ut_i; \ + for (_ut_i = 0; _ut_i < (len); _ut_i++) { \ + (a)->icd.dtor(utarray_eltptr(a, (pos) + _ut_i)); \ + } \ + } \ + if ((a)->i > ((pos) + (len))) { \ + memmove(_utarray_eltptr(a, pos), _utarray_eltptr(a, (pos) + (len)), \ + ((a)->i - ((pos) + (len))) * (a)->icd.sz); \ + } \ + (a)->i -= (len); \ +} while(0) + +#define utarray_renew(a,u) do { \ + if (a) utarray_clear(a); \ + else utarray_new(a, u); \ +} while(0) + +#define utarray_clear(a) do { \ + if ((a)->i > 0) { \ + if ((a)->icd.dtor) { \ + unsigned _ut_i; \ + for(_ut_i=0; _ut_i < (a)->i; _ut_i++) { \ + (a)->icd.dtor(_utarray_eltptr(a, _ut_i)); \ + } \ + } \ + (a)->i = 0; \ + } \ +} while(0) + +#define utarray_sort(a,cmp) do { \ + qsort((a)->d, (a)->i, (a)->icd.sz, cmp); \ +} while(0) + +#define utarray_find(a,v,cmp) bsearch((v),(a)->d,(a)->i,(a)->icd.sz,cmp) + +#define utarray_front(a) (((a)->i) ? (_utarray_eltptr(a,0)) : NULL) +#define utarray_next(a,e) (((e)==NULL) ? utarray_front(a) : (((a)->i != utarray_eltidx(a,e)+1) ? _utarray_eltptr(a,utarray_eltidx(a,e)+1) : NULL)) +#define utarray_prev(a,e) (((e)==NULL) ? utarray_back(a) : ((utarray_eltidx(a,e) != 0) ? _utarray_eltptr(a,utarray_eltidx(a,e)-1) : NULL)) +#define utarray_back(a) (((a)->i) ? (_utarray_eltptr(a,(a)->i-1)) : NULL) +#define utarray_eltidx(a,e) (((char*)(e) - (a)->d) / (a)->icd.sz) + +/* last we pre-define a few icd for common utarrays of ints and strings */ +static void utarray_str_cpy(void *dst, const void *src) { + char **_src = (char**)src, **_dst = (char**)dst; + *_dst = (*_src == NULL) ? NULL : strdup(*_src); +} +static void utarray_str_dtor(void *elt) { + char **eltc = (char**)elt; + if (*eltc != NULL) free(*eltc); +} +static const UT_icd ut_str_icd UTARRAY_UNUSED = {sizeof(char*),NULL,utarray_str_cpy,utarray_str_dtor}; +static const UT_icd ut_int_icd UTARRAY_UNUSED = {sizeof(int),NULL,NULL,NULL}; +static const UT_icd ut_ptr_icd UTARRAY_UNUSED = {sizeof(void*),NULL,NULL,NULL}; + + +#endif /* UTARRAY_H */