Max/korenkonder_ReDIVA
1
0
Fork 0
mirror of https://github.com/korenkonder/ReDIVA.git synced 2026-10-09 23:58:26 +03:00
Code Issues Packages Projects Releases Wiki Activity

Temp commit. Sound

Browse Source
This commit is contained in:
korenkonder
2022-10-03 15:54:28 +03:00
parent 64c1775f92
commit a15befd8fb
232 changed files with 19396 additions and 12396 deletions
Download Patch File Download Diff File Expand all files Collapse all files
extern/lib/libdeflatestatic.lib
Vendored
BIN
View File
Binary file not shown.
extern/lib/libogg.lib
Vendored
BIN
View File
Binary file not shown.
extern/lib/libogg.pdb
Vendored
BIN
View File
Binary file not shown.
extern/lib/liboggd.lib
Vendored
BIN
View File
Binary file not shown.
extern/lib/liboggd.pdb
Vendored
BIN
View File
Binary file not shown.
extern/lib/libvorbis.lib
Vendored
BIN
View File
Binary file not shown.
extern/lib/libvorbis.pdb
Vendored
BIN
View File
Binary file not shown.
extern/lib/libvorbisd.lib
Vendored
BIN
View File
Binary file not shown.
extern/lib/libvorbisd.pdb
Vendored
BIN
View File
Binary file not shown.
extern/lib/libvorbisfile.lib
Vendored
BIN
View File
Binary file not shown.
extern/lib/libvorbisfile.pdb
Vendored
BIN
View File
Binary file not shown.
extern/lib/libvorbisfiled.lib
Vendored
BIN
View File
Binary file not shown.
extern/lib/libvorbisfiled.pdb
Vendored
BIN
View File
Binary file not shown.
extern/src/libdeflate.h
Vendored
+5 -13
View File
@@ -10,15 +10,15 @@ extern "C" {
#endif
#define LIBDEFLATE_VERSION_MAJOR 1
#define LIBDEFLATE_VERSION_MINOR 12
#define LIBDEFLATE_VERSION_STRING "1.12"
#define LIBDEFLATE_VERSION_MINOR 14
#define LIBDEFLATE_VERSION_STRING "1.14"
#include <stddef.h>
#include <stdint.h>
/*
* On Windows, if you want to link to the DLL version of libdeflate, then
* #define LIBDEFLATE_DLL. Note that the calling convention is "stdcall".
* #define LIBDEFLATE_DLL. Note that the calling convention is "cdecl".
*/
#ifdef LIBDEFLATE_DLL
# ifdef BUILDING_LIBDEFLATE
@@ -31,12 +31,6 @@ extern "C" {
# define LIBDEFLATEEXPORT
#endif
#if defined(_WIN32) && !defined(_WIN64) && defined(LIBDEFLATE_DLL)
# define LIBDEFLATEAPI_ABI __stdcall
#else
# define LIBDEFLATEAPI_ABI
#endif
#if defined(BUILDING_LIBDEFLATE) && defined(__GNUC__) && \
defined(_WIN32) && !defined(_WIN64)
/*
@@ -44,13 +38,11 @@ extern "C" {
* Realign the stack when entering libdeflate to avoid crashing in SSE/AVX
* code when called from an MSVC-compiled application.
*/
# define LIBDEFLATEAPI_STACKALIGN __attribute__((force_align_arg_pointer))
# define LIBDEFLATEAPI __attribute__((force_align_arg_pointer))
#else
# define LIBDEFLATEAPI_STACKALIGN
# define LIBDEFLATEAPI
#endif
#define LIBDEFLATEAPI LIBDEFLATEAPI_ABI LIBDEFLATEAPI_STACKALIGN
/* ========================================================================== */
/* Compression */
/* ========================================================================== */
extern/src/ogg/ogg.h
Vendored
+209
View File
@@ -0,0 +1,209 @@
/********************************************************************
* *
* THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
* USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
* GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
* IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
* *
* THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
* by the Xiph.Org Foundation http://www.xiph.org/ *
* *
********************************************************************
function: toplevel libogg include
********************************************************************/
#ifndef _OGG_H
#define _OGG_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stddef.h>
#include <ogg/os_types.h>
typedef struct {
void *iov_base;
size_t iov_len;
} ogg_iovec_t;
typedef struct {
long endbyte;
int endbit;
unsigned char *buffer;
unsigned char *ptr;
long storage;
} oggpack_buffer;
/* ogg_page is used to encapsulate the data in one Ogg bitstream page *****/
typedef struct {
unsigned char *header;
long header_len;
unsigned char *body;
long body_len;
} ogg_page;
/* ogg_stream_state contains the current encode/decode state of a logical
Ogg bitstream **********************************************************/
typedef struct {
unsigned char *body_data; /* bytes from packet bodies */
long body_storage; /* storage elements allocated */
long body_fill; /* elements stored; fill mark */
long body_returned; /* elements of fill returned */
int *lacing_vals; /* The values that will go to the segment table */
ogg_int64_t *granule_vals; /* granulepos values for headers. Not compact
this way, but it is simple coupled to the
lacing fifo */
long lacing_storage;
long lacing_fill;
long lacing_packet;
long lacing_returned;
unsigned char header[282]; /* working space for header encode */
int header_fill;
int e_o_s; /* set when we have buffered the last packet in the
logical bitstream */
int b_o_s; /* set after we've written the initial page
of a logical bitstream */
long serialno;
long pageno;
ogg_int64_t packetno; /* sequence number for decode; the framing
knows where there's a hole in the data,
but we need coupling so that the codec
(which is in a separate abstraction
layer) also knows about the gap */
ogg_int64_t granulepos;
} ogg_stream_state;
/* ogg_packet is used to encapsulate the data and metadata belonging
to a single raw Ogg/Vorbis packet *************************************/
typedef struct {
unsigned char *packet;
long bytes;
long b_o_s;
long e_o_s;
ogg_int64_t granulepos;
ogg_int64_t packetno; /* sequence number for decode; the framing
knows where there's a hole in the data,
but we need coupling so that the codec
(which is in a separate abstraction
layer) also knows about the gap */
} ogg_packet;
typedef struct {
unsigned char *data;
int storage;
int fill;
int returned;
int unsynced;
int headerbytes;
int bodybytes;
} ogg_sync_state;
/* Ogg BITSTREAM PRIMITIVES: bitstream ************************/
extern void oggpack_writeinit(oggpack_buffer *b);
extern int oggpack_writecheck(oggpack_buffer *b);
extern void oggpack_writetrunc(oggpack_buffer *b,long bits);
extern void oggpack_writealign(oggpack_buffer *b);
extern void oggpack_writecopy(oggpack_buffer *b,void *source,long bits);
extern void oggpack_reset(oggpack_buffer *b);
extern void oggpack_writeclear(oggpack_buffer *b);
extern void oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes);
extern void oggpack_write(oggpack_buffer *b,unsigned long value,int bits);
extern long oggpack_look(oggpack_buffer *b,int bits);
extern long oggpack_look1(oggpack_buffer *b);
extern void oggpack_adv(oggpack_buffer *b,int bits);
extern void oggpack_adv1(oggpack_buffer *b);
extern long oggpack_read(oggpack_buffer *b,int bits);
extern long oggpack_read1(oggpack_buffer *b);
extern long oggpack_bytes(oggpack_buffer *b);
extern long oggpack_bits(oggpack_buffer *b);
extern unsigned char *oggpack_get_buffer(oggpack_buffer *b);
extern void oggpackB_writeinit(oggpack_buffer *b);
extern int oggpackB_writecheck(oggpack_buffer *b);
extern void oggpackB_writetrunc(oggpack_buffer *b,long bits);
extern void oggpackB_writealign(oggpack_buffer *b);
extern void oggpackB_writecopy(oggpack_buffer *b,void *source,long bits);
extern void oggpackB_reset(oggpack_buffer *b);
extern void oggpackB_writeclear(oggpack_buffer *b);
extern void oggpackB_readinit(oggpack_buffer *b,unsigned char *buf,int bytes);
extern void oggpackB_write(oggpack_buffer *b,unsigned long value,int bits);
extern long oggpackB_look(oggpack_buffer *b,int bits);
extern long oggpackB_look1(oggpack_buffer *b);
extern void oggpackB_adv(oggpack_buffer *b,int bits);
extern void oggpackB_adv1(oggpack_buffer *b);
extern long oggpackB_read(oggpack_buffer *b,int bits);
extern long oggpackB_read1(oggpack_buffer *b);
extern long oggpackB_bytes(oggpack_buffer *b);
extern long oggpackB_bits(oggpack_buffer *b);
extern unsigned char *oggpackB_get_buffer(oggpack_buffer *b);
/* Ogg BITSTREAM PRIMITIVES: encoding **************************/
extern int ogg_stream_packetin(ogg_stream_state *os, ogg_packet *op);
extern int ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov,
int count, long e_o_s, ogg_int64_t granulepos);
extern int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og);
extern int ogg_stream_pageout_fill(ogg_stream_state *os, ogg_page *og, int nfill);
extern int ogg_stream_flush(ogg_stream_state *os, ogg_page *og);
extern int ogg_stream_flush_fill(ogg_stream_state *os, ogg_page *og, int nfill);
/* Ogg BITSTREAM PRIMITIVES: decoding **************************/
extern int ogg_sync_init(ogg_sync_state *oy);
extern int ogg_sync_clear(ogg_sync_state *oy);
extern int ogg_sync_reset(ogg_sync_state *oy);
extern int ogg_sync_destroy(ogg_sync_state *oy);
extern int ogg_sync_check(ogg_sync_state *oy);
extern char *ogg_sync_buffer(ogg_sync_state *oy, long size);
extern int ogg_sync_wrote(ogg_sync_state *oy, long bytes);
extern long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og);
extern int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og);
extern int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og);
extern int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op);
extern int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op);
/* Ogg BITSTREAM PRIMITIVES: general ***************************/
extern int ogg_stream_init(ogg_stream_state *os,int serialno);
extern int ogg_stream_clear(ogg_stream_state *os);
extern int ogg_stream_reset(ogg_stream_state *os);
extern int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno);
extern int ogg_stream_destroy(ogg_stream_state *os);
extern int ogg_stream_check(ogg_stream_state *os);
extern int ogg_stream_eos(ogg_stream_state *os);
extern void ogg_page_checksum_set(ogg_page *og);
extern int ogg_page_version(const ogg_page *og);
extern int ogg_page_continued(const ogg_page *og);
extern int ogg_page_bos(const ogg_page *og);
extern int ogg_page_eos(const ogg_page *og);
extern ogg_int64_t ogg_page_granulepos(const ogg_page *og);
extern int ogg_page_serialno(const ogg_page *og);
extern long ogg_page_pageno(const ogg_page *og);
extern int ogg_page_packets(const ogg_page *og);
extern void ogg_packet_clear(ogg_packet *op);
#ifdef __cplusplus
}
#endif
#endif /* _OGG_H */
extern/src/ogg/os_types.h
Vendored
+158
View File
@@ -0,0 +1,158 @@
/********************************************************************
* *
* THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
* USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
* GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
* IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
* *
* THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002 *
* by the Xiph.Org Foundation http://www.xiph.org/ *
* *
********************************************************************
function: Define a consistent set of types on each platform.
********************************************************************/
#ifndef _OS_TYPES_H
#define _OS_TYPES_H
/* make it easy on the folks that want to compile the libs with a
different malloc than stdlib */
#define _ogg_malloc malloc
#define _ogg_calloc calloc
#define _ogg_realloc realloc
#define _ogg_free free
#if defined(_WIN32)
# if defined(__CYGWIN__)
# include <stdint.h>
typedef int16_t ogg_int16_t;
typedef uint16_t ogg_uint16_t;
typedef int32_t ogg_int32_t;
typedef uint32_t ogg_uint32_t;
typedef int64_t ogg_int64_t;
typedef uint64_t ogg_uint64_t;
# elif defined(__MINGW32__)
# include <sys/types.h>
typedef short ogg_int16_t;
typedef unsigned short ogg_uint16_t;
typedef int ogg_int32_t;
typedef unsigned int ogg_uint32_t;
typedef long long ogg_int64_t;
typedef unsigned long long ogg_uint64_t;
# elif defined(__MWERKS__)
typedef long long ogg_int64_t;
typedef unsigned long long ogg_uint64_t;
typedef int ogg_int32_t;
typedef unsigned int ogg_uint32_t;
typedef short ogg_int16_t;
typedef unsigned short ogg_uint16_t;
# else
# if defined(_MSC_VER) && (_MSC_VER >= 1800) /* MSVC 2013 and newer */
# include <stdint.h>
typedef int16_t ogg_int16_t;
typedef uint16_t ogg_uint16_t;
typedef int32_t ogg_int32_t;
typedef uint32_t ogg_uint32_t;
typedef int64_t ogg_int64_t;
typedef uint64_t ogg_uint64_t;
# else
/* MSVC/Borland */
typedef __int64 ogg_int64_t;
typedef __int32 ogg_int32_t;
typedef unsigned __int32 ogg_uint32_t;
typedef unsigned __int64 ogg_uint64_t;
typedef __int16 ogg_int16_t;
typedef unsigned __int16 ogg_uint16_t;
# endif
# endif
#elif (defined(__APPLE__) && defined(__MACH__)) /* MacOS X Framework build */
# include <sys/types.h>
typedef int16_t ogg_int16_t;
typedef u_int16_t ogg_uint16_t;
typedef int32_t ogg_int32_t;
typedef u_int32_t ogg_uint32_t;
typedef int64_t ogg_int64_t;
typedef u_int64_t ogg_uint64_t;
#elif defined(__HAIKU__)
/* Haiku */
# include <sys/types.h>
typedef short ogg_int16_t;
typedef unsigned short ogg_uint16_t;
typedef int ogg_int32_t;
typedef unsigned int ogg_uint32_t;
typedef long long ogg_int64_t;
typedef unsigned long long ogg_uint64_t;
#elif defined(__BEOS__)
/* Be */
# include <inttypes.h>
typedef int16_t ogg_int16_t;
typedef uint16_t ogg_uint16_t;
typedef int32_t ogg_int32_t;
typedef uint32_t ogg_uint32_t;
typedef int64_t ogg_int64_t;
typedef uint64_t ogg_uint64_t;
#elif defined (__EMX__)
/* OS/2 GCC */
typedef short ogg_int16_t;
typedef unsigned short ogg_uint16_t;
typedef int ogg_int32_t;
typedef unsigned int ogg_uint32_t;
typedef long long ogg_int64_t;
typedef unsigned long long ogg_uint64_t;
#elif defined (DJGPP)
/* DJGPP */
typedef short ogg_int16_t;
typedef int ogg_int32_t;
typedef unsigned int ogg_uint32_t;
typedef long long ogg_int64_t;
typedef unsigned long long ogg_uint64_t;
#elif defined(R5900)
/* PS2 EE */
typedef long ogg_int64_t;
typedef unsigned long ogg_uint64_t;
typedef int ogg_int32_t;
typedef unsigned ogg_uint32_t;
typedef short ogg_int16_t;
#elif defined(__SYMBIAN32__)
/* Symbian GCC */
typedef signed short ogg_int16_t;
typedef unsigned short ogg_uint16_t;
typedef signed int ogg_int32_t;
typedef unsigned int ogg_uint32_t;
typedef long long int ogg_int64_t;
typedef unsigned long long int ogg_uint64_t;
#elif defined(__TMS320C6X__)
/* TI C64x compiler */
typedef signed short ogg_int16_t;
typedef unsigned short ogg_uint16_t;
typedef signed int ogg_int32_t;
typedef unsigned int ogg_uint32_t;
typedef long long int ogg_int64_t;
typedef unsigned long long int ogg_uint64_t;
#else
# include <ogg/config_types.h>
#endif
#endif /* _OS_TYPES_H */
extern/src/vorbis/codec.h
Vendored
+242
View File
@@ -0,0 +1,242 @@
/********************************************************************
* *
* THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
* USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
* GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
* IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
* *
* THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2001 *
* by the Xiph.Org Foundation https://xiph.org/ *
********************************************************************
function: libvorbis codec headers
********************************************************************/
#ifndef _vorbis_codec_h_
#define _vorbis_codec_h_
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#include <ogg/ogg.h>
typedef struct vorbis_info{
int version;
int channels;
long rate;
/* The below bitrate declarations are *hints*.
Combinations of the three values carry the following implications:
all three set to the same value:
implies a fixed rate bitstream
only nominal set:
implies a VBR stream that averages the nominal bitrate. No hard
upper/lower limit
upper and or lower set:
implies a VBR bitstream that obeys the bitrate limits. nominal
may also be set to give a nominal rate.
none set:
the coder does not care to speculate.
*/
long bitrate_upper;
long bitrate_nominal;
long bitrate_lower;
long bitrate_window;
void *codec_setup;
} vorbis_info;
/* vorbis_dsp_state buffers the current vorbis audio
analysis/synthesis state. The DSP state belongs to a specific
logical bitstream ****************************************************/
typedef struct vorbis_dsp_state{
int analysisp;
vorbis_info *vi;
float **pcm;
float **pcmret;
int pcm_storage;
int pcm_current;
int pcm_returned;
int preextrapolate;
int eofflag;
long lW;
long W;
long nW;
long centerW;
ogg_int64_t granulepos;
ogg_int64_t sequence;
ogg_int64_t glue_bits;
ogg_int64_t time_bits;
ogg_int64_t floor_bits;
ogg_int64_t res_bits;
void *backend_state;
} vorbis_dsp_state;
typedef struct vorbis_block{
/* necessary stream state for linking to the framing abstraction */
float **pcm; /* this is a pointer into local storage */
oggpack_buffer opb;
long lW;
long W;
long nW;
int pcmend;
int mode;
int eofflag;
ogg_int64_t granulepos;
ogg_int64_t sequence;
vorbis_dsp_state *vd; /* For read-only access of configuration */
/* local storage to avoid remallocing; it's up to the mapping to
structure it */
void *localstore;
long localtop;
long localalloc;
long totaluse;
struct alloc_chain *reap;
/* bitmetrics for the frame */
long glue_bits;
long time_bits;
long floor_bits;
long res_bits;
void *internal;
} vorbis_block;
/* vorbis_block is a single block of data to be processed as part of
the analysis/synthesis stream; it belongs to a specific logical
bitstream, but is independent from other vorbis_blocks belonging to
that logical bitstream. *************************************************/
struct alloc_chain{
void *ptr;
struct alloc_chain *next;
};
/* vorbis_info contains all the setup information specific to the
specific compression/decompression mode in progress (eg,
psychoacoustic settings, channel setup, options, codebook
etc). vorbis_info and substructures are in backends.h.
*********************************************************************/
/* the comments are not part of vorbis_info so that vorbis_info can be
static storage */
typedef struct vorbis_comment{
/* unlimited user comment fields. libvorbis writes 'libvorbis'
whatever vendor is set to in encode */
char **user_comments;
int *comment_lengths;
int comments;
char *vendor;
} vorbis_comment;
/* libvorbis encodes in two abstraction layers; first we perform DSP
and produce a packet (see docs/analysis.txt). The packet is then
coded into a framed OggSquish bitstream by the second layer (see
docs/framing.txt). Decode is the reverse process; we sync/frame
the bitstream and extract individual packets, then decode the
packet back into PCM audio.
The extra framing/packetizing is used in streaming formats, such as
files. Over the net (such as with UDP), the framing and
packetization aren't necessary as they're provided by the transport
and the streaming layer is not used */
/* Vorbis PRIMITIVES: general ***************************************/
extern void vorbis_info_init(vorbis_info *vi);
extern void vorbis_info_clear(vorbis_info *vi);
extern int vorbis_info_blocksize(vorbis_info *vi,int zo);
extern void vorbis_comment_init(vorbis_comment *vc);
extern void vorbis_comment_add(vorbis_comment *vc, const char *comment);
extern void vorbis_comment_add_tag(vorbis_comment *vc,
const char *tag, const char *contents);
extern char *vorbis_comment_query(vorbis_comment *vc, const char *tag, int count);
extern int vorbis_comment_query_count(vorbis_comment *vc, const char *tag);
extern void vorbis_comment_clear(vorbis_comment *vc);
extern int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb);
extern int vorbis_block_clear(vorbis_block *vb);
extern void vorbis_dsp_clear(vorbis_dsp_state *v);
extern double vorbis_granule_time(vorbis_dsp_state *v,
ogg_int64_t granulepos);
extern const char *vorbis_version_string(void);
/* Vorbis PRIMITIVES: analysis/DSP layer ****************************/
extern int vorbis_analysis_init(vorbis_dsp_state *v,vorbis_info *vi);
extern int vorbis_commentheader_out(vorbis_comment *vc, ogg_packet *op);
extern int vorbis_analysis_headerout(vorbis_dsp_state *v,
vorbis_comment *vc,
ogg_packet *op,
ogg_packet *op_comm,
ogg_packet *op_code);
extern float **vorbis_analysis_buffer(vorbis_dsp_state *v,int vals);
extern int vorbis_analysis_wrote(vorbis_dsp_state *v,int vals);
extern int vorbis_analysis_blockout(vorbis_dsp_state *v,vorbis_block *vb);
extern int vorbis_analysis(vorbis_block *vb,ogg_packet *op);
extern int vorbis_bitrate_addblock(vorbis_block *vb);
extern int vorbis_bitrate_flushpacket(vorbis_dsp_state *vd,
ogg_packet *op);
/* Vorbis PRIMITIVES: synthesis layer *******************************/
extern int vorbis_synthesis_idheader(ogg_packet *op);
extern int vorbis_synthesis_headerin(vorbis_info *vi,vorbis_comment *vc,
ogg_packet *op);
extern int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi);
extern int vorbis_synthesis_restart(vorbis_dsp_state *v);
extern int vorbis_synthesis(vorbis_block *vb,ogg_packet *op);
extern int vorbis_synthesis_trackonly(vorbis_block *vb,ogg_packet *op);
extern int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb);
extern int vorbis_synthesis_pcmout(vorbis_dsp_state *v,float ***pcm);
extern int vorbis_synthesis_lapout(vorbis_dsp_state *v,float ***pcm);
extern int vorbis_synthesis_read(vorbis_dsp_state *v,int samples);
extern long vorbis_packet_blocksize(vorbis_info *vi,ogg_packet *op);
extern int vorbis_synthesis_halfrate(vorbis_info *v,int flag);
extern int vorbis_synthesis_halfrate_p(vorbis_info *v);
/* Vorbis ERRORS and return codes ***********************************/
#define OV_FALSE -1
#define OV_EOF -2
#define OV_HOLE -3
#define OV_EREAD -128
#define OV_EFAULT -129
#define OV_EIMPL -130
#define OV_EINVAL -131
#define OV_ENOTVORBIS -132
#define OV_EBADHEADER -133
#define OV_EVERSION -134
#define OV_ENOTAUDIO -135
#define OV_EBADPACKET -136
#define OV_EBADLINK -137
#define OV_ENOSEEK -138
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif
extern/src/vorbis/vorbisenc.h
Vendored
+435
View File
@@ -0,0 +1,435 @@
/********************************************************************
* *
* THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
* USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
* GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
* IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
* *
* THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2001 *
* by the Xiph.Org Foundation https://xiph.org/ *
* *
********************************************************************
function: vorbis encode-engine setup
********************************************************************/
/** \file
* Libvorbisenc is a convenient API for setting up an encoding
* environment using libvorbis. Libvorbisenc encapsulates the
* actions needed to set up the encoder properly.
*/
#ifndef _OV_ENC_H_
#define _OV_ENC_H_
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#include "codec.h"
/**
* This is the primary function within libvorbisenc for setting up managed
* bitrate modes.
*
* Before this function is called, the \ref vorbis_info
* struct should be initialized by using vorbis_info_init() from the libvorbis
* API. After encoding, vorbis_info_clear() should be called.
*
* The max_bitrate, nominal_bitrate, and min_bitrate settings are used to set
* constraints for the encoded file. This function uses these settings to
* select the appropriate encoding mode and set it up.
*
* \param vi Pointer to an initialized \ref vorbis_info struct.
* \param channels The number of channels to be encoded.
* \param rate The sampling rate of the source audio.
* \param max_bitrate Desired maximum bitrate (limit). -1 indicates unset.
* \param nominal_bitrate Desired average, or central, bitrate. -1 indicates unset.
* \param min_bitrate Desired minimum bitrate. -1 indicates unset.
*
* \return Zero for success, and negative values for failure.
*
* \retval 0 Success.
* \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption.
* \retval OV_EINVAL Invalid setup request, eg, out of range argument.
* \retval OV_EIMPL Unimplemented mode; unable to comply with bitrate request.
*/
extern int vorbis_encode_init(vorbis_info *vi,
long channels,
long rate,
long max_bitrate,
long nominal_bitrate,
long min_bitrate);
/**
* This function performs step-one of a three-step bitrate-managed encode
* setup. It functions similarly to the one-step setup performed by \ref
* vorbis_encode_init but allows an application to make further encode setup
* tweaks using \ref vorbis_encode_ctl before finally calling \ref
* vorbis_encode_setup_init to complete the setup process.
*
* Before this function is called, the \ref vorbis_info struct should be
* initialized by using vorbis_info_init() from the libvorbis API. After
* encoding, vorbis_info_clear() should be called.
*
* The max_bitrate, nominal_bitrate, and min_bitrate settings are used to set
* constraints for the encoded file. This function uses these settings to
* select the appropriate encoding mode and set it up.
*
* \param vi Pointer to an initialized vorbis_info struct.
* \param channels The number of channels to be encoded.
* \param rate The sampling rate of the source audio.
* \param max_bitrate Desired maximum bitrate (limit). -1 indicates unset.
* \param nominal_bitrate Desired average, or central, bitrate. -1 indicates unset.
* \param min_bitrate Desired minimum bitrate. -1 indicates unset.
*
* \return Zero for success, and negative for failure.
*
* \retval 0 Success
* \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption.
* \retval OV_EINVAL Invalid setup request, eg, out of range argument.
* \retval OV_EIMPL Unimplemented mode; unable to comply with bitrate request.
*/
extern int vorbis_encode_setup_managed(vorbis_info *vi,
long channels,
long rate,
long max_bitrate,
long nominal_bitrate,
long min_bitrate);
/**
* This function performs step-one of a three-step variable bitrate
* (quality-based) encode setup. It functions similarly to the one-step setup
* performed by \ref vorbis_encode_init_vbr() but allows an application to
* make further encode setup tweaks using \ref vorbis_encode_ctl() before
* finally calling \ref vorbis_encode_setup_init to complete the setup
* process.
*
* Before this function is called, the \ref vorbis_info struct should be
* initialized by using \ref vorbis_info_init() from the libvorbis API. After
* encoding, vorbis_info_clear() should be called.
*
* \param vi Pointer to an initialized vorbis_info struct.
* \param channels The number of channels to be encoded.
* \param rate The sampling rate of the source audio.
* \param quality Desired quality level, currently from -0.1 to 1.0 (lo to hi).
*
* \return Zero for success, and negative values for failure.
*
* \retval 0 Success
* \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption.
* \retval OV_EINVAL Invalid setup request, eg, out of range argument.
* \retval OV_EIMPL Unimplemented mode; unable to comply with quality level request.
*/
extern int vorbis_encode_setup_vbr(vorbis_info *vi,
long channels,
long rate,
float quality
);
/**
* This is the primary function within libvorbisenc for setting up variable
* bitrate ("quality" based) modes.
*
*
* Before this function is called, the vorbis_info struct should be
* initialized by using vorbis_info_init() from the libvorbis API. After
* encoding, vorbis_info_clear() should be called.
*
* \param vi Pointer to an initialized vorbis_info struct.
* \param channels The number of channels to be encoded.
* \param rate The sampling rate of the source audio.
* \param base_quality Desired quality level, currently from -0.1 to 1.0 (lo to hi).
*
*
* \return Zero for success, or a negative number for failure.
*
* \retval 0 Success
* \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption.
* \retval OV_EINVAL Invalid setup request, eg, out of range argument.
* \retval OV_EIMPL Unimplemented mode; unable to comply with quality level request.
*/
extern int vorbis_encode_init_vbr(vorbis_info *vi,
long channels,
long rate,
float base_quality
);
/**
* This function performs the last stage of three-step encoding setup, as
* described in the API overview under managed bitrate modes.
*
* Before this function is called, the \ref vorbis_info struct should be
* initialized by using vorbis_info_init() from the libvorbis API, one of
* \ref vorbis_encode_setup_managed() or \ref vorbis_encode_setup_vbr() called to
* initialize the high-level encoding setup, and \ref vorbis_encode_ctl()
* called if necessary to make encoding setup changes.
* vorbis_encode_setup_init() finalizes the highlevel encoding structure into
* a complete encoding setup after which the application may make no further
* setup changes.
*
* After encoding, vorbis_info_clear() should be called.
*
* \param vi Pointer to an initialized \ref vorbis_info struct.
*
* \return Zero for success, and negative values for failure.
*
* \retval 0 Success.
* \retval OV_EFAULT Internal logic fault; indicates a bug or heap/stack corruption.
*
* \retval OV_EINVAL Attempt to use vorbis_encode_setup_init() without first
* calling one of vorbis_encode_setup_managed() or vorbis_encode_setup_vbr() to
* initialize the high-level encoding setup
*
*/
extern int vorbis_encode_setup_init(vorbis_info *vi);
/**
* This function implements a generic interface to miscellaneous encoder
* settings similar to the classic UNIX 'ioctl()' system call. Applications
* may use vorbis_encode_ctl() to query or set bitrate management or quality
* mode details by using one of several \e request arguments detailed below.
* vorbis_encode_ctl() must be called after one of
* vorbis_encode_setup_managed() or vorbis_encode_setup_vbr(). When used
* to modify settings, \ref vorbis_encode_ctl() must be called before \ref
* vorbis_encode_setup_init().
*
* \param vi Pointer to an initialized vorbis_info struct.
*
* \param number Specifies the desired action; See \ref encctlcodes "the list
* of available requests".
*
* \param arg void * pointing to a data structure matching the request
* argument.
*
* \retval 0 Success. Any further return information (such as the result of a
* query) is placed into the storage pointed to by *arg.
*
* \retval OV_EINVAL Invalid argument, or an attempt to modify a setting after
* calling vorbis_encode_setup_init().
*
* \retval OV_EIMPL Unimplemented or unknown request
*/
extern int vorbis_encode_ctl(vorbis_info *vi,int number,void *arg);
/**
* \deprecated This is a deprecated interface. Please use vorbis_encode_ctl()
* with the \ref ovectl_ratemanage2_arg struct and \ref
* OV_ECTL_RATEMANAGE2_GET and \ref OV_ECTL_RATEMANAGE2_SET calls in new code.
*
* The \ref ovectl_ratemanage_arg structure is used with vorbis_encode_ctl()
* and the \ref OV_ECTL_RATEMANAGE_GET, \ref OV_ECTL_RATEMANAGE_SET, \ref
* OV_ECTL_RATEMANAGE_AVG, \ref OV_ECTL_RATEMANAGE_HARD calls in order to
* query and modify specifics of the encoder's bitrate management
* configuration.
*/
struct ovectl_ratemanage_arg {
int management_active; /**< nonzero if bitrate management is active*/
/** hard lower limit (in kilobits per second) below which the stream bitrate
will never be allowed for any given bitrate_hard_window seconds of time.*/
long bitrate_hard_min;
/** hard upper limit (in kilobits per second) above which the stream bitrate
will never be allowed for any given bitrate_hard_window seconds of time.*/
long bitrate_hard_max;
/** the window period (in seconds) used to regulate the hard bitrate minimum
and maximum*/
double bitrate_hard_window;
/** soft lower limit (in kilobits per second) below which the average bitrate
tracker will start nudging the bitrate higher.*/
long bitrate_av_lo;
/** soft upper limit (in kilobits per second) above which the average bitrate
tracker will start nudging the bitrate lower.*/
long bitrate_av_hi;
/** the window period (in seconds) used to regulate the average bitrate
minimum and maximum.*/
double bitrate_av_window;
/** Regulates the relative centering of the average and hard windows; in
libvorbis 1.0 and 1.0.1, the hard window regulation overlapped but
followed the average window regulation. In libvorbis 1.1 a bit-reservoir
interface replaces the old windowing interface; the older windowing
interface is simulated and this field has no effect.*/
double bitrate_av_window_center;
};
/**
* \name struct ovectl_ratemanage2_arg
*
* The ovectl_ratemanage2_arg structure is used with vorbis_encode_ctl() and
* the OV_ECTL_RATEMANAGE2_GET and OV_ECTL_RATEMANAGE2_SET calls in order to
* query and modify specifics of the encoder's bitrate management
* configuration.
*
*/
struct ovectl_ratemanage2_arg {
int management_active; /**< nonzero if bitrate management is active */
/** Lower allowed bitrate limit in kilobits per second */
long bitrate_limit_min_kbps;
/** Upper allowed bitrate limit in kilobits per second */
long bitrate_limit_max_kbps;
long bitrate_limit_reservoir_bits; /**<Size of the bitrate reservoir in bits */
/** Regulates the bitrate reservoir's preferred fill level in a range from 0.0
* to 1.0; 0.0 tries to bank bits to buffer against future bitrate spikes, 1.0
* buffers against future sudden drops in instantaneous bitrate. Default is
* 0.1
*/
double bitrate_limit_reservoir_bias;
/** Average bitrate setting in kilobits per second */
long bitrate_average_kbps;
/** Slew rate limit setting for average bitrate adjustment; sets the minimum
* time in seconds the bitrate tracker may swing from one extreme to the
* other when boosting or damping average bitrate.
*/
double bitrate_average_damping;
};
/**
* \name vorbis_encode_ctl() codes
*
* \anchor encctlcodes
*
* These values are passed as the \c number parameter of vorbis_encode_ctl().
* The type of the referent of that function's \c arg pointer depends on these
* codes.
*/
/*@{*/
/**
* Query the current encoder bitrate management setting.
*
*Argument: <tt>struct ovectl_ratemanage2_arg *</tt>
*
* Used to query the current encoder bitrate management setting. Also used to
* initialize fields of an ovectl_ratemanage2_arg structure for use with
* \ref OV_ECTL_RATEMANAGE2_SET.
*/
#define OV_ECTL_RATEMANAGE2_GET 0x14
/**
* Set the current encoder bitrate management settings.
*
* Argument: <tt>struct ovectl_ratemanage2_arg *</tt>
*
* Used to set the current encoder bitrate management settings to the values
* listed in the ovectl_ratemanage2_arg. Passing a NULL pointer will disable
* bitrate management.
*/
#define OV_ECTL_RATEMANAGE2_SET 0x15
/**
* Returns the current encoder hard-lowpass setting (kHz) in the double
* pointed to by arg.
*
* Argument: <tt>double *</tt>
*/
#define OV_ECTL_LOWPASS_GET 0x20
/**
* Sets the encoder hard-lowpass to the value (kHz) pointed to by arg. Valid
* lowpass settings range from 2 to 99.
*
* Argument: <tt>double *</tt>
*/
#define OV_ECTL_LOWPASS_SET 0x21
/**
* Returns the current encoder impulse block setting in the double pointed
* to by arg.
*
* Argument: <tt>double *</tt>
*/
#define OV_ECTL_IBLOCK_GET 0x30
/**
* Sets the impulse block bias to the the value pointed to by arg.
*
* Argument: <tt>double *</tt>
*
* Valid range is -15.0 to 0.0 [default]. A negative impulse block bias will
* direct to encoder to use more bits when incoding short blocks that contain
* strong impulses, thus improving the accuracy of impulse encoding.
*/
#define OV_ECTL_IBLOCK_SET 0x31
/**
* Returns the current encoder coupling setting in the int pointed
* to by arg.
*
* Argument: <tt>int *</tt>
*/
#define OV_ECTL_COUPLING_GET 0x40
/**
* Enables/disables channel coupling in multichannel encoding according to arg.
*
* Argument: <tt>int *</tt>
*
* Zero disables channel coupling for multichannel inputs, nonzer enables
* channel coupling. Setting has no effect on monophonic encoding or
* multichannel counts that do not offer coupling. At present, coupling is
* available for stereo and 5.1 encoding.
*/
#define OV_ECTL_COUPLING_SET 0x41
/* deprecated rate management supported only for compatibility */
/**
* Old interface to querying bitrate management settings.
*
* Deprecated after move to bit-reservoir style management in 1.1 rendered
* this interface partially obsolete.
* \deprecated Please use \ref OV_ECTL_RATEMANAGE2_GET instead.
*
* Argument: <tt>struct ovectl_ratemanage_arg *</tt>
*/
#define OV_ECTL_RATEMANAGE_GET 0x10
/**
* Old interface to modifying bitrate management settings.
*
* deprecated after move to bit-reservoir style management in 1.1 rendered
* this interface partially obsolete.
*
* \deprecated Please use \ref OV_ECTL_RATEMANAGE2_SET instead.
*
* Argument: <tt>struct ovectl_ratemanage_arg *</tt>
*/
#define OV_ECTL_RATEMANAGE_SET 0x11
/**
* Old interface to setting average-bitrate encoding mode.
*
* Deprecated after move to bit-reservoir style management in 1.1 rendered
* this interface partially obsolete.
*
* \deprecated Please use \ref OV_ECTL_RATEMANAGE2_SET instead.
*
* Argument: <tt>struct ovectl_ratemanage_arg *</tt>
*/
#define OV_ECTL_RATEMANAGE_AVG 0x12
/**
* Old interface to setting bounded-bitrate encoding modes.
*
* deprecated after move to bit-reservoir style management in 1.1 rendered
* this interface partially obsolete.
*
* \deprecated Please use \ref OV_ECTL_RATEMANAGE2_SET instead.
*
* Argument: <tt>struct ovectl_ratemanage_arg *</tt>
*/
#define OV_ECTL_RATEMANAGE_HARD 0x13
/*@}*/
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif
extern/src/vorbis/vorbisfile.h
Vendored
+205
View File
@@ -0,0 +1,205 @@
/********************************************************************
* *
* THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
* USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
* GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
* IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
* *
* THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
* by the Xiph.Org Foundation https://xiph.org/ *
* *
********************************************************************
function: stdio-based convenience library for opening/seeking/decoding
********************************************************************/
#ifndef _OV_FILE_H_
#define _OV_FILE_H_
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#include <stdio.h>
#include "codec.h"
/* The function prototypes for the callbacks are basically the same as for
* the stdio functions fread, fseek, fclose, ftell.
* The one difference is that the FILE * arguments have been replaced with
* a void * - this is to be used as a pointer to whatever internal data these
* functions might need. In the stdio case, it's just a FILE * cast to a void *
*
* If you use other functions, check the docs for these functions and return
* the right values. For seek_func(), you *MUST* return -1 if the stream is
* unseekable
*/
typedef struct {
size_t (*read_func) (void *ptr, size_t size, size_t nmemb, void *datasource);
int (*seek_func) (void *datasource, ogg_int64_t offset, int whence);
int (*close_func) (void *datasource);
long (*tell_func) (void *datasource);
} ov_callbacks;
#ifndef OV_EXCLUDE_STATIC_CALLBACKS
/* a few sets of convenient callbacks, especially for use under
* Windows where ov_open_callbacks() should always be used instead of
* ov_open() to avoid problems with incompatible crt.o version linking
* issues. */
static int _ov_header_fseek_wrap(FILE *f,ogg_int64_t off,int whence){
if(f==NULL)return(-1);
#ifdef __MINGW32__
return fseeko64(f,off,whence);
#elif defined (_WIN32)
return _fseeki64(f,off,whence);
#else
return fseek(f,off,whence);
#endif
}
/* These structs below (OV_CALLBACKS_DEFAULT etc) are defined here as
* static data. That means that every file which includes this header
* will get its own copy of these structs whether it uses them or
* not unless it #defines OV_EXCLUDE_STATIC_CALLBACKS.
* These static symbols are essential on platforms such as Windows on
* which several different versions of stdio support may be linked to
* by different DLLs, and we need to be certain we know which one
* we're using (the same one as the main application).
*/
static ov_callbacks OV_CALLBACKS_DEFAULT = {
(size_t (*)(void *, size_t, size_t, void *)) fread,
(int (*)(void *, ogg_int64_t, int)) _ov_header_fseek_wrap,
(int (*)(void *)) fclose,
(long (*)(void *)) ftell
};
static ov_callbacks OV_CALLBACKS_NOCLOSE = {
(size_t (*)(void *, size_t, size_t, void *)) fread,
(int (*)(void *, ogg_int64_t, int)) _ov_header_fseek_wrap,
(int (*)(void *)) NULL,
(long (*)(void *)) ftell
};
static ov_callbacks OV_CALLBACKS_STREAMONLY = {
(size_t (*)(void *, size_t, size_t, void *)) fread,
(int (*)(void *, ogg_int64_t, int)) NULL,
(int (*)(void *)) fclose,
(long (*)(void *)) NULL
};
static ov_callbacks OV_CALLBACKS_STREAMONLY_NOCLOSE = {
(size_t (*)(void *, size_t, size_t, void *)) fread,
(int (*)(void *, ogg_int64_t, int)) NULL,
(int (*)(void *)) NULL,
(long (*)(void *)) NULL
};
#endif
#define NOTOPEN 0
#define PARTOPEN 1
#define OPENED 2
#define STREAMSET 3
#define INITSET 4
typedef struct OggVorbis_File {
void *datasource; /* Pointer to a FILE *, etc. */
int seekable;
ogg_int64_t offset;
ogg_int64_t end;
ogg_sync_state oy;
/* If the FILE handle isn't seekable (eg, a pipe), only the current
stream appears */
int links;
ogg_int64_t *offsets;
ogg_int64_t *dataoffsets;
long *serialnos;
ogg_int64_t *pcmlengths; /* overloaded to maintain binary
compatibility; x2 size, stores both
beginning and end values */
vorbis_info *vi;
vorbis_comment *vc;
/* Decoding working state local storage */
ogg_int64_t pcm_offset;
int ready_state;
long current_serialno;
int current_link;
double bittrack;
double samptrack;
ogg_stream_state os; /* take physical pages, weld into a logical
stream of packets */
vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */
vorbis_block vb; /* local working space for packet->PCM decode */
ov_callbacks callbacks;
} OggVorbis_File;
extern int ov_clear(OggVorbis_File *vf);
extern int ov_fopen(const char *path,OggVorbis_File *vf);
extern int ov_open(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes);
extern int ov_open_callbacks(void *datasource, OggVorbis_File *vf,
const char *initial, long ibytes, ov_callbacks callbacks);
extern int ov_test(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes);
extern int ov_test_callbacks(void *datasource, OggVorbis_File *vf,
const char *initial, long ibytes, ov_callbacks callbacks);
extern int ov_test_open(OggVorbis_File *vf);
extern long ov_bitrate(OggVorbis_File *vf,int i);
extern long ov_bitrate_instant(OggVorbis_File *vf);
extern long ov_streams(OggVorbis_File *vf);
extern long ov_seekable(OggVorbis_File *vf);
extern long ov_serialnumber(OggVorbis_File *vf,int i);
extern ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i);
extern ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i);
extern double ov_time_total(OggVorbis_File *vf,int i);
extern int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos);
extern int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos);
extern int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos);
extern int ov_time_seek(OggVorbis_File *vf,double pos);
extern int ov_time_seek_page(OggVorbis_File *vf,double pos);
extern int ov_raw_seek_lap(OggVorbis_File *vf,ogg_int64_t pos);
extern int ov_pcm_seek_lap(OggVorbis_File *vf,ogg_int64_t pos);
extern int ov_pcm_seek_page_lap(OggVorbis_File *vf,ogg_int64_t pos);
extern int ov_time_seek_lap(OggVorbis_File *vf,double pos);
extern int ov_time_seek_page_lap(OggVorbis_File *vf,double pos);
extern ogg_int64_t ov_raw_tell(OggVorbis_File *vf);
extern ogg_int64_t ov_pcm_tell(OggVorbis_File *vf);
extern double ov_time_tell(OggVorbis_File *vf);
extern vorbis_info *ov_info(OggVorbis_File *vf,int link);
extern vorbis_comment *ov_comment(OggVorbis_File *vf,int link);
extern long ov_read_float(OggVorbis_File *vf,float ***pcm_channels,int samples,
int *bitstream);
extern long ov_read_filter(OggVorbis_File *vf,char *buffer,int length,
int bigendianp,int word,int sgned,int *bitstream,
void (*filter)(float **pcm,long channels,long samples,void *filter_param),void *filter_param);
extern long ov_read(OggVorbis_File *vf,char *buffer,int length,
int bigendianp,int word,int sgned,int *bitstream);
extern int ov_crosslap(OggVorbis_File *vf1,OggVorbis_File *vf2);
extern int ov_halfrate(OggVorbis_File *vf,int flag);
extern int ov_halfrate_p(OggVorbis_File *vf);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif
src/CRE/Glitter/curve.cpp
+6 -6
View File
@@ -275,7 +275,7 @@ namespace Glitter {
bool has_error = false;
bool has_error_lerp = false;
for (size_t j = 1; j < left_count; j++) {
float_t val = lerp(a[0], a[left_count - 1], (float_t)j / (float_t)left_count);
float_t val = lerp_def(a[0], a[left_count - 1], (float_t)j / (float_t)left_count);
if (fabsf(val - a[0]) > reverse_bias[0]) {
has_error = true;
if (fabsf(val - a[j]) > reverse_bias[1]) {
@@ -312,7 +312,7 @@ namespace Glitter {
for (size_t j = 1; j < i - 1; j++) {
float_t _t1 = 0.0f;
float_t _t2 = 0.0f;
interpolate_chs_reverse_step_value(a, left_count, &_t1, &_t2, 0, i, j, step);
interpolate_chs_reverse_step_value(a, left_count, _t1, _t2, 0, i, j, step);
tt1 += _t1;
tt2 += _t2;
}
@@ -326,7 +326,7 @@ namespace Glitter {
for (size_t j = 1; j < i; j++) {
float_t val = interpolate_chs_value(a[0], a[i], t1, t2, 0.0f,
(float_t)(i * step), (float_t)(j * step));
float_t val_lerp = lerp(a[0], a[i], (float_t)j / (float_t)i);
float_t val_lerp = lerp_def(a[0], a[i], (float_t)j / (float_t)i);
if (fabsf(val - a[0]) > reverse_bias[0]) {
has_error = true;
constant = false;
@@ -342,7 +342,7 @@ namespace Glitter {
constant = true;
}
if (fabsf(t1) > 1.0f || fabsf(t2) > 1.0f)
if (fabsf(t1) > 0.5f || fabsf(t2) > 0.5f)
has_error_hermite = true;
if (!has_error_hermite) {
@@ -401,8 +401,8 @@ namespace Glitter {
key.tangent2 = 0.0f;
key.random_range = arr_b[count - 1];
keys_rev.push_back(key);
free(arr_a);
free(arr_b);
free_def(arr_a);
free_def(arr_b);
Recalculate(GLT_VAL);
}
src/CRE/Glitter/effect.cpp
-163
View File
@@ -31,166 +31,3 @@ namespace Glitter {
delete i;
}
}
/*
#include "effect.hpp"
#include "animation.hpp"
#include "emitter.hpp"
static bool glitter_effect_pack_file(GLT, f2_struct* st, glitter_effect* a3);
glitter_effect::glitter_effect(GLT) : name(), translation(), rotation(), data() {
}
glitter_effect::~glitter_effect() {
free(data.ext_anim);
for (glitter_emitter*& i : emitters)
delete i;
}
bool glitter_effect_parse_file(EffectGroup* a1,
f2_struct* st, std::vector<glitter_effect*>* vec, object_database* obj_db) {
glitter_effect* effect;
if (!st || !st->header.data_size)
return false;
effect = new glitter_effect(a1->type);
effect->version = st->header.version;
if (!glitter_effect_unpack_file(a1->type, st->data.data(),
effect, st->header.use_big_endian, obj_db)) {
delete effect;
return false;
}
for (f2_struct& i : st->sub_structs) {
if (!i.header.data_size)
continue;
if (i.header.signature == reverse_endianness_uint32_t('ANIM'))
glitter_animation_parse_file(a1->type, &i, &effect->animation, glitter_effect_curve_flags);
else if (i.header.signature == reverse_endianness_uint32_t('EMIT'))
glitter_emitter_parse_file(a1, &i, &effect->emitters, effect);
}
vec->push_back(effect);
return true;
}
static bool glitter_effect_pack_file(GLT, f2_struct* st, glitter_effect* a2) {
size_t l;
size_t d;
glitter_effect_ext_anim* ext_anim;
glitter_effect_file_flag flags;
if (a2->version != 6 && a2->version != 7)
return false;
ext_anim = a2->data.ext_anim;
l = 0;
uint32_t o;
enrs e;
enrs_entry ee;
ee = { 0, 2, 56, 1 };
ee.append(0, 1, ENRS_QWORD);
ee.append(0, 12, ENRS_DWORD);
e.vec.push_back(ee);
l += o = 56;
if (a2->version == 7) {
ee = { 0, 1, 4, 1 };
ee.append(0, 1, ENRS_DWORD);
e.vec.push_back(ee);
l += o = 4;
}
ee = { 0, 1, 4, 1 };
ee.append(0, 1, ENRS_DWORD);
e.vec.push_back(ee);
l += o = 4;
if (~a2->data.flags & EFFECT_LOCAL && ext_anim)
if (ext_anim->flags & EFFECT_EXT_ANIM_CHARA_ANIM) {
ee = { 0, 1, 12, 1 };
ee.append(0, 3, ENRS_DWORD);
e.vec.push_back(ee);
l += o = 12;
}
else {
ee = { 0, 2, 140, 1 };
ee.append(0, 1, ENRS_QWORD);
ee.append(0, 1, ENRS_DWORD);
e.vec.push_back(ee);
l += o = 140;
}
l = align_val(l, 0x10);
st->data.resize(l);
d = (size_t)st->data.data();
st->enrs = e;
flags = (glitter_effect_file_flag)0;
if (a2->data.flags & EFFECT_ALPHA)
enum_or(flags, EFFECT_FILE_ALPHA);
if (a2->data.flags & EFFECT_FOG)
enum_or(flags, EFFECT_FILE_FOG);
else if (a2->data.flags & EFFECT_FOG_HEIGHT)
enum_or(flags, EFFECT_FILE_FOG_HEIGHT);
if (a2->data.flags & EFFECT_EMISSION)
enum_or(flags, EFFECT_FILE_EMISSION);
*(uint64_t*)d = GLT_VAL != Glitter::FT
? hash_utf8_murmurhash(a2->name)
: hash_utf8_fnv1a64m(a2->name);
*(int32_t*)(d + 8) = a2->data.appear_time;
*(int32_t*)(d + 12) = a2->data.life_time;
*(int32_t*)(d + 16) = a2->data.start_time;
*(int32_t*)(d + 20) = 0xFFFFFFFF;
*(int32_t*)(d + 24) = a2->data.flags & EFFECT_LOOP ? 1 : 0;
*(vec3*)(d + 28) = a2->translation;
*(vec3*)(d + 40) = a2->rotation;
*(int32_t*)(d + 52) = flags;
d += 56;
if (a2->version == 7) {
*(float_t*)d = a2->data.emission;
d += 4;
}
if (a2->data.flags & EFFECT_LOCAL) {
*(int32_t*)d = 1;
d += 4;
}
else if (ext_anim)
if (ext_anim->flags & EFFECT_EXT_ANIM_CHARA_ANIM) {
*(int32_t*)d = 2;
d += 4;
glitter_effect_ext_anim_flag ext_anim_flag
= (glitter_effect_ext_anim_flag)(ext_anim->flags & ~EFFECT_EXT_ANIM_CHARA_ANIM);
*(int32_t*)d = ext_anim->chara_index;
*(int32_t*)(d + 4) = ext_anim_flag;
*(int32_t*)(d + 8) = ext_anim->node_index;
}
else {
*(int32_t*)d = 3;
d += 4;
*(uint64_t*)d = ext_anim->object_hash;
*(int32_t*)(d + 8) = ext_anim->flags;
memcpy((uint8_t*)(d + 12), ext_anim->mesh_name, 128);
}
else {
*(int32_t*)d = 0;
d += 4;
}
st->header.signature = reverse_endianness_uint32_t('EFCT');
st->header.length = 0x20;
st->header.use_big_endian = false;
st->header.use_section_size = true;
st->header.version = a2->version;
return true;
}
*/
src/CRE/Glitter/effect_group.cpp
+1 -1
View File
@@ -23,7 +23,7 @@ namespace Glitter {
if (resources) {
for (texture** i = resources; *i; i++)
texture_free(*i);
free(resources);
free_def(resources);
resources = 0;
}
src/CRE/Glitter/effect_inst.cpp
+93 -90
View File
@@ -110,7 +110,7 @@ namespace Glitter {
random_ptr = &GPM_VAL->random;
ext_anim = 0;
if (~eff->data.flags & EFFECT_LOCAL && data.ext_anim) {
if (!(eff->data.flags & EFFECT_LOCAL) && data.ext_anim) {
F2EffectInst::ExtAnim* inst_ext_anim = new F2EffectInst::ExtAnim;
if (inst_ext_anim) {
Effect::ExtAnim* ext_anim = data.ext_anim;
@@ -240,7 +240,7 @@ namespace Glitter {
}
bool F2EffectInst::HasEnded(bool a2) {
if (~flags & EFFECT_INST_FREE)
if (!(flags & EFFECT_INST_FREE))
return false;
else if (!a2)
return true;
@@ -256,7 +256,7 @@ namespace Glitter {
frame1 = 0.0;
flags = (EffectInstFlag)0;
if (~data.flags & EFFECT_LOCAL && data.ext_anim) {
if (!(data.flags & EFFECT_LOCAL) && data.ext_anim) {
if (ext_anim) {
Effect::ExtAnim* ext_anim = data.ext_anim;
if (ext_anim->flags & EFFECT_EXT_ANIM_SET_ONCE)
@@ -328,7 +328,7 @@ namespace Glitter {
}
void F2EffectInst::CtrlMat(GPM, GLT) {
if (~flags & EFFECT_INST_JUST_INIT)
if (!(flags & EFFECT_INST_JUST_INIT))
return;
vec3 trans = translation;
@@ -359,12 +359,10 @@ namespace Glitter {
if (!ext_anim || !data.ext_anim)
return;
if (~flags & EFFECT_INST_HAS_EXT_ANIM || (flags & EFFECT_INST_SET_EXT_ANIM_ONCE
if (!(flags & EFFECT_INST_HAS_EXT_ANIM) || (flags & EFFECT_INST_SET_EXT_ANIM_ONCE
&& flags & EFFECT_INST_HAS_EXT_ANIM_TRANS))
return;
mat4* obj_mat = 0;
mat4 temp;
mat4 mat;
int32_t chara_id;
@@ -398,8 +396,69 @@ namespace Glitter {
ext_anim->mat = mat;
goto SetFlags;
}
else if (flags & EFFECT_INST_GET_EXT_ANIM_MAT) {
mat4 temp;
mat4* obj_mat = 0;
if (ext_anim->a3da_id != -1)
obj_mat = auth_3d_data_get_auth_3d_object_mat(ext_anim->a3da_id,
ext_anim->object_index, ext_anim->object_is_hrc, &temp);
if (~flags & EFFECT_INST_GET_EXT_ANIM_MAT) {
if (!obj_mat) {
ext_anim->a3da_id = auth_3d_data_get_auth_3d_id(ext_anim->object,
&ext_anim->object_index, &ext_anim->object_is_hrc);
if (ext_anim->a3da_id == -1)
return;
ext_anim->mesh_index = -1;
obj_mat = auth_3d_data_get_auth_3d_object_mat(ext_anim->a3da_id,
ext_anim->object_index, ext_anim->object_is_hrc, &temp);
if (!obj_mat)
return;
}
mat = mat4_identity;
chara_id = auth_3d_data_get_chara_id(ext_anim->a3da_id);
if (chara_id >= 0 && chara_id < ROB_CHARA_COUNT) {
rob_chara* rob_chr = rob_chara_array_get(chara_id);
if (rob_chr) {
mat = rob_chr->data.adjust_data.mat;
vec3 scale;
mat4_get_scale(&mat, &scale);
vec3_sub_scalar(scale, 1.0f, ext_anim_scale);
ext_anim_scale.z = 0.0f;
enum_or(flags, EFFECT_INST_HAS_EXT_ANIM_SCALE);
}
}
if (ext_anim->mesh_name) {
if (ext_anim->mesh_index == -1)
ext_anim->mesh_index = object_storage_get_obj_mesh_index(
ext_anim->object, ext_anim->mesh_name);
if (ext_anim->mesh_index != -1) {
obj_mesh* mesh = object_storage_get_obj_mesh_by_index(
ext_anim->object, ext_anim->mesh_index);
if (mesh) {
mat4_mult(obj_mat, &mat, &mat);
ext_anim->mat = mat;
ext_anim->translation = mesh->bounding_sphere.center;
goto SetFlags;
}
}
}
else {
mat4_mult(obj_mat, &mat, &mat);
if (flags & EFFECT_INST_EXT_ANIM_TRANS_ONLY) {
ext_anim->mat = mat4_identity;
mat4_get_translation(&mat, &ext_anim->translation);
}
else
ext_anim->mat = mat;
goto SetFlags;
}
}
else {
if (ext_anim->mesh_index == -1) {
if (!ext_anim->mesh_name)
return;
@@ -416,66 +475,6 @@ namespace Glitter {
goto SetFlags;
}
}
return;
}
if (ext_anim->a3da_id != -1)
obj_mat = auth_3d_data_get_auth_3d_object_mat(ext_anim->a3da_id,
ext_anim->object_index, ext_anim->object_is_hrc, &temp);
if (!obj_mat) {
ext_anim->a3da_id = auth_3d_data_get_auth_3d_id(ext_anim->object,
&ext_anim->object_index, &ext_anim->object_is_hrc, 0);
if (ext_anim->a3da_id == -1)
return;
ext_anim->mesh_index = -1;
obj_mat = auth_3d_data_get_auth_3d_object_mat(ext_anim->a3da_id,
ext_anim->object_index, ext_anim->object_is_hrc, &temp);
if (!obj_mat)
return;
}
mat = mat4_identity;
chara_id = auth_3d_data_get_chara_id(ext_anim->a3da_id);
if (chara_id >= 0 && chara_id < ROB_CHARA_COUNT) {
rob_chara* rob_chr = rob_chara_array_get(chara_id);
if (rob_chr) {
mat = rob_chr->data.adjust_data.mat;
vec3 scale;
mat4_get_scale(&mat, &scale);
vec3_sub_scalar(scale, 1.0f, ext_anim_scale);
ext_anim_scale.z = 0.0f;
enum_or(flags, EFFECT_INST_HAS_EXT_ANIM_SCALE);
}
}
if (ext_anim->mesh_name) {
if (ext_anim->mesh_index == -1)
ext_anim->mesh_index = object_storage_get_obj_mesh_index(
ext_anim->object, ext_anim->mesh_name);
if (ext_anim->mesh_index != -1) {
obj_mesh* mesh = object_storage_get_obj_mesh_by_index(
ext_anim->object, ext_anim->mesh_index);
if (mesh) {
mat4_mult(obj_mat, &mat, &mat);
ext_anim->mat = mat;
ext_anim->translation = mesh->bounding_sphere.center;
goto SetFlags;
}
}
}
else {
mat4_mult(obj_mat, &mat, &mat);
if (flags & EFFECT_INST_EXT_ANIM_TRANS_ONLY) {
ext_anim->mat = mat4_identity;
mat4_get_translation(&mat, &ext_anim->translation);
}
else
ext_anim->mat = mat;
goto SetFlags;
}
return;
@@ -487,7 +486,7 @@ namespace Glitter {
}
bool F2EffectInst::GetExtAnimMat(mat4* mat) {
if (~flags & EFFECT_INST_HAS_EXT_ANIM_TRANS || !ext_anim)
if (!(flags & EFFECT_INST_HAS_EXT_ANIM_TRANS) || !ext_anim)
return false;
vec3 trans = ext_anim->translation;
@@ -496,7 +495,7 @@ namespace Glitter {
}
void F2EffectInst::GetExtColor(float_t& r, float_t& g, float_t& b, float_t& a) {
if (~flags & EFFECT_INST_EXT_COLOR)
if (!(flags & EFFECT_INST_EXT_COLOR))
return;
if (flags & EFFECT_INST_SET_EXT_COLOR) {
@@ -623,7 +622,7 @@ namespace Glitter {
random = GPM_VAL->CounterGet();
random_shared.value = random;
if (~eff->data.flags & EFFECT_LOCAL && data.ext_anim_x) {
if (!(eff->data.flags & EFFECT_LOCAL) && data.ext_anim_x) {
XEffectInst::ExtAnim* inst_ext_anim = new XEffectInst::ExtAnim;
if (inst_ext_anim) {
Effect::ExtAnimX* ext_anim = data.ext_anim_x;
@@ -777,7 +776,7 @@ namespace Glitter {
}
bool XEffectInst::HasEnded(bool a2) {
if (~flags & EFFECT_INST_FREE)
if (!(flags & EFFECT_INST_FREE))
return false;
else if (!a2)
return true;
@@ -793,7 +792,7 @@ namespace Glitter {
frame1 = 0.0;
flags = (EffectInstFlag)0;
if (~data.flags & EFFECT_LOCAL && data.ext_anim_x) {
if (!(data.flags & EFFECT_LOCAL) && data.ext_anim_x) {
if (ext_anim) {
Effect::ExtAnimX* ext_anim = data.ext_anim_x;
if (ext_anim->flags & EFFECT_EXT_ANIM_SET_ONCE)
@@ -876,7 +875,7 @@ namespace Glitter {
}
void XEffectInst::CtrlMat(GPM) {
if (~flags & EFFECT_INST_JUST_INIT)
if (!(flags & EFFECT_INST_JUST_INIT))
return;
vec3 trans = translation;
@@ -911,7 +910,7 @@ namespace Glitter {
if (!ext_anim || !data.ext_anim_x)
return;
if (~flags & EFFECT_INST_HAS_EXT_ANIM || (flags & EFFECT_INST_SET_EXT_ANIM_ONCE
if (!(flags & EFFECT_INST_HAS_EXT_ANIM) || (flags & EFFECT_INST_SET_EXT_ANIM_ONCE
&& flags & EFFECT_INST_HAS_EXT_ANIM_TRANS))
return;
@@ -925,10 +924,10 @@ namespace Glitter {
if (!rob_chr)
return;
mat4& mat = rob_chr->data.adjust_data.mat;
mat4* mat = &rob_chr->data.adjust_data.mat;
vec3 scale;
mat4_get_scale(&mat, &scale);
mat4_get_scale(mat, &scale);
vec3_sub_scalar(scale, 1.0f, ext_anim_scale);
ext_anim_scale.z = 0.0f;
enum_or(flags, EFFECT_INST_HAS_EXT_ANIM_SCALE);
@@ -942,19 +941,19 @@ namespace Glitter {
if (bone_index != -1) {
mat4* bone_mat = rob_chr->get_bone_data_mat(bone_index);
if (bone_mat)
SetExtAnim(&mat, bone_mat, 0, set_flags);
SetExtAnim(mat, bone_mat, 0, set_flags);
}
else
SetExtAnim(&mat, 0, 0, set_flags);
SetExtAnim(mat, 0, 0, set_flags);
}
else if (flags & EFFECT_INST_GET_EXT_ANIM_MAT) {
mat4 temp;
mat4* mat = 0;
mat4* obj_mat = 0;
if (ext_anim->a3da_id != -1)
mat = auth_3d_data_get_auth_3d_object_mat(ext_anim->a3da_id,
obj_mat = auth_3d_data_get_auth_3d_object_mat(ext_anim->a3da_id,
ext_anim->object_index, ext_anim->object_is_hrc, &temp);
if (!mat) {
if (!obj_mat) {
ext_anim->a3da_id = auth_3d_data_get_auth_3d_id(
ext_anim->file_name_hash, ext_anim->object_hash,
&ext_anim->object_index, &ext_anim->object_is_hrc, ext_anim->instance_id);
@@ -962,18 +961,22 @@ namespace Glitter {
return;
ext_anim->mesh_index = -1;
mat = auth_3d_data_get_auth_3d_object_mat(ext_anim->a3da_id,
obj_mat = auth_3d_data_get_auth_3d_object_mat(ext_anim->a3da_id,
ext_anim->object_index, ext_anim->object_is_hrc, &temp);
if (!mat)
if (!obj_mat)
return;
}
const mat4* mat = &mat4_identity;
int32_t chara_id = auth_3d_data_get_chara_id(ext_anim->a3da_id);
if (chara_id >= 0 && chara_id < ROB_CHARA_COUNT) {
rob_chara* rob_chr = rob_chara_array_get(chara_id);
if (rob_chr) {
mat = &rob_chr->data.adjust_data.mat;
vec3 scale;
mat4_get_scale(&rob_chr->data.adjust_data.mat, &scale);
mat4_get_scale(mat, &scale);
vec3_sub_scalar(scale, 1.0f, ext_anim_scale);
ext_anim_scale.z = 0.0f;
enum_or(flags, EFFECT_INST_HAS_EXT_ANIM_SCALE);
@@ -990,12 +993,12 @@ namespace Glitter {
ext_anim->object_hash, ext_anim->mesh_index);
if (mesh) {
vec3* trans = &mesh->bounding_sphere.center;
SetExtAnim(mat, 0, trans, true);
SetExtAnim(mat, obj_mat, trans, true);
}
}
}
else
SetExtAnim(mat, 0, 0, true);
SetExtAnim(mat, obj_mat, 0, true);
}
else if (ext_anim->object_hash != hash_murmurhash_empty) {
@@ -1019,7 +1022,7 @@ namespace Glitter {
}
bool XEffectInst::GetExtAnimMat(mat4* mat) {
if (~flags & EFFECT_INST_HAS_EXT_ANIM_TRANS || !ext_anim)
if (!(flags & EFFECT_INST_HAS_EXT_ANIM_TRANS) || !ext_anim)
return false;
vec3 trans = ext_anim->translation;
@@ -1028,7 +1031,7 @@ namespace Glitter {
}
void XEffectInst::GetExtColor(float_t& r, float_t& g, float_t& b, float_t& a) {
if (~flags & EFFECT_INST_EXT_COLOR)
if (!(flags & EFFECT_INST_EXT_COLOR))
return;
if (flags & EFFECT_INST_SET_EXT_COLOR) {
@@ -1125,7 +1128,7 @@ namespace Glitter {
}
}
void XEffectInst::SetExtAnim(mat4* a2, mat4* a3, vec3* trans, bool set_flags) {
void XEffectInst::SetExtAnim(const mat4* a2, const mat4* a3, const vec3* trans, bool set_flags) {
EffectInstFlag flags = this->flags;
if (a2) {
mat4 mat = *a2;
src/CRE/Glitter/emitter.cpp
-145
View File
@@ -40,148 +40,3 @@ namespace Glitter {
delete i;
}
}
/*
#include "emitter.hpp"
#include "animation.hpp"
#include "curve.hpp"
#include "particle.hpp"
static bool glitter_emitter_pack_file(GLT, f2_struct* st, glitter_emitter* a2);
bool glitter_emitter_unparse_file(GLT, EffectGroup* a1,
f2_struct* st, glitter_emitter* a3, glitter_effect* effect) {
if (!glitter_emitter_pack_file(GLT_VAL, st, a3))
return false;
f2_struct s;
if (glitter_animation_unparse_file(GLT_VAL, &s, &a3->animation, glitter_emitter_curve_flags))
st->sub_structs.push_back(s);
for (glitter_particle*& i : a3->particles) {
if (!i)
continue;
f2_struct s;
if (glitter_particle_unparse_file(GLT_VAL, a1, &s, i, effect))
st->sub_structs.push_back(s);
}
return true;
}
static bool glitter_emitter_pack_file(GLT, f2_struct* st, glitter_emitter* a2) {
size_t l;
size_t d;
if (a2->version != 1 && a2->version != 2)
return false;
switch (a2->data.type) {
case EMITTER_BOX:
case EMITTER_CYLINDER:
case EMITTER_SPHERE:
case EMITTER_POLYGON:
break;
default:
return false;
}
l = 0;
uint32_t o;
enrs e;
enrs_entry ee;
ee = { 0, 5, 96, 1 };
ee.append(0, 5, ENRS_DWORD);
ee.append(0, 2, ENRS_WORD);
ee.append(0, 2, ENRS_DWORD);
ee.append(0, 2, ENRS_WORD);
ee.append(0, 15, ENRS_DWORD);
e.vec.push_back(ee);
l += o = 96;
switch (a2->data.type) {
case EMITTER_BOX:
ee = { o, 1, 12, 1 };
ee.append(0, 3, ENRS_DWORD);
e.vec.push_back(ee);
l += o = 12;
break;
case EMITTER_CYLINDER:
ee = { o, 1, 20, 1 };
ee.append(0, 5, ENRS_DWORD);
e.vec.push_back(ee);
l += o = 20;
break;
case EMITTER_SPHERE:
ee = { o, 1, 16, 1 };
ee.append(0, 4, ENRS_DWORD);
e.vec.push_back(ee);
l += o = 16;
break;
case EMITTER_POLYGON:
ee = { o, 1, 8, 1 };
ee.append(0, 2, ENRS_DWORD);
e.vec.push_back(ee);
l += o = 8;
break;
}
l = align_val(l, 0x10);
st->data.resize(l);
d = (size_t)st->data.data();
st->enrs = e;
*(int32_t*)d = a2->data.start_time;
*(int32_t*)(d + 4) = a2->data.life_time;
*(int32_t*)(d + 8) = a2->data.loop_start_time;
*(int32_t*)(d + 12) = a2->data.loop_end_time;
*(int32_t*)(d + 16) = a2->data.flags;
*(int16_t*)(d + 20) = (int16_t)a2->data.type;
*(int16_t*)(d + 22) = (int16_t)a2->data.direction;
*(float_t*)(d + 24) = a2->data.emission_interval;
*(float_t*)(d + 28) = a2->data.particles_per_emission;
*(int16_t*)(d + 32) = 0;
*(int16_t*)(d + 34) = 0;
*(vec3*)(d + 36) = a2->translation;
*(vec3*)(d + 48) = a2->rotation;
*(vec3*)(d + 60) = a2->scale;
*(vec3*)(d + 72) = a2->data.rotation_add;
*(vec3*)(d + 84) = a2->data.rotation_add_random;
d += 96;
switch (a2->data.type) {
case EMITTER_BOX:
*(vec3*)d = a2->data.box.size;
break;
case EMITTER_CYLINDER:
*(float_t*)d = a2->data.cylinder.radius;
*(float_t*)(d + 4) = a2->data.cylinder.height;
*(float_t*)(d + 8) = a2->data.cylinder.start_angle;
*(float_t*)(d + 12) = a2->data.cylinder.end_angle;
*(int32_t*)(d + 16) = ((int32_t)a2->data.cylinder.direction << 1)
| (a2->data.cylinder.on_edge ? 1 : 0);
break;
case EMITTER_SPHERE:
*(float_t*)d = a2->data.sphere.radius;
*(float_t*)(d + 4) = a2->data.sphere.latitude;
*(float_t*)(d + 8) = a2->data.sphere.longitude;
*(int32_t*)(d + 12) = ((int32_t)a2->data.sphere.direction << 1)
| (a2->data.sphere.on_edge ? 1 : 0);
break;
case EMITTER_POLYGON:
*(float_t*)d = a2->data.polygon.size;
*(int32_t*)(d + 4) = a2->data.polygon.count;
break;
}
st->header.signature = reverse_endianness_uint32_t('EMIT');
st->header.length = 0x20;
st->header.use_big_endian = false;
st->header.use_section_size = true;
st->header.version = a2->version;
return true;
}
*/
src/CRE/Glitter/file_reader.cpp
+7 -7
View File
@@ -42,8 +42,8 @@ namespace Glitter {
this->hash = GLT_VAL != Glitter::FT
? hash_utf8_murmurhash(file_temp)
: hash_utf8_fnv1a64m(file_temp);
free(path_temp);
free(file_temp);
free_def(path_temp);
free_def(file_temp);
}
FileReader::~FileReader() {
@@ -760,10 +760,10 @@ namespace Glitter {
}
if (!texture_txp_set_load(&eff_group->resources_tex, &eff_group->resources, ids)) {
free(ids);
free_def(ids);
return false;
}
free(ids);
free_def(ids);
for (Effect*& i : eff_group->effects) {
if (!i)
@@ -1853,9 +1853,9 @@ namespace Glitter {
ptcl->data.split_u = split_u;
ptcl->data.split_v = split_v;
ptcl->data.uv_index_type = uv_index_type;
ptcl->data.uv_index = max(uv_index, 0);
ptcl->data.uv_index = max_def(uv_index, 0);
ptcl->data.frame_step_uv = frame_step_uv;
ptcl->data.uv_index_start = max(uv_index_start, 0);
ptcl->data.uv_index_start = max_def(uv_index_start, 0);
ptcl->data.uv_index_end = uv_index_end;
ptcl->data.split_uv.x = (float_t)split_u;
ptcl->data.split_uv.y = (float_t)split_v;
@@ -1885,7 +1885,7 @@ namespace Glitter {
else if (uv_index_end >= 0 && uv_index > uv_index_end)
ptcl->data.uv_index = uv_index_end;
ptcl->data.uv_index = min(ptcl->data.uv_index, uv_max_count);
ptcl->data.uv_index = min_def(ptcl->data.uv_index, uv_max_count);
break;
}
src/CRE/Glitter/file_writer.cpp
+506 -210
View File
File diff suppressed because it is too large Load Diff
src/CRE/Glitter/glitter.cpp
+1 -1
View File
@@ -268,7 +268,7 @@ namespace Glitter {
vec3_cross(*vec1, *vec2, *axis);
vec3_length(*axis, *angle);
if (*angle >= 0.000001f)
*angle = asinf(min(*angle, 1.0f));
*angle = asinf(min_def(*angle, 1.0f));
else {
*angle = 0.0f;
axis->x = vec1->z;
src/CRE/Glitter/glitter.hpp
+24 -16
View File
@@ -941,7 +941,7 @@ namespace Glitter {
void GetExtColor(float_t& r, float_t& g, float_t& b, float_t& a);
FogType GetFog();
void GetValue();
void SetExtAnim(mat4* a2, mat4* a3, vec3* trans, bool set_flags);
void SetExtAnim(const mat4* a2, const mat4* a3, const vec3* trans, bool set_flags);
};
class Emitter : public Node {
@@ -1130,24 +1130,28 @@ namespace Glitter {
FileWriter();
void PackCurve(f2_struct* st, Curve* c);
bool PackDivaList(EffectGroup* eff_group, f2_struct* st);
void PackCurve(f2_struct* st, Curve* c, bool big_endian);
bool PackDivaList(EffectGroup* eff_group, f2_struct* st, bool big_endian);
bool PackDivaResource(EffectGroup* eff_group, f2_struct* st);
bool PackDivaResourceHashes(EffectGroup* eff_group, f2_struct* st);
bool PackEffect(f2_struct* st, Effect* eff);
bool PackEmitter(f2_struct* st, Emitter* emit);
bool PackParticle(EffectGroup* eff_group, f2_struct* st, Particle* ptcl, Effect* eff);
bool UnparseAnimation(f2_struct* st, Animation* anim, CurveTypeFlags flags);
bool UnparseCurve(f2_struct* st, Curve* c);
bool UnparseDivaEffect(EffectGroup* eff_group, f2_struct* st);
bool UnparseDivaList(EffectGroup* eff_group, f2_struct* st);
bool PackDivaResourceHashes(EffectGroup* eff_group, f2_struct* st, bool big_endian);
bool PackEffect(f2_struct* st, Effect* eff, bool big_endian);
bool PackEmitter(f2_struct* st, Emitter* emit, bool big_endian);
bool PackParticle(EffectGroup* eff_group,
f2_struct* st, Particle* ptcl, Effect* eff, bool big_endian);
bool UnparseAnimation(f2_struct* st, Animation* anim, CurveTypeFlags flags, bool big_endian);
bool UnparseCurve(f2_struct* st, Curve* c, bool big_endian);
bool UnparseDivaEffect(EffectGroup* eff_group, f2_struct* st, bool big_endian);
bool UnparseDivaList(EffectGroup* eff_group, f2_struct* st, bool big_endian);
bool UnparseDivaResource(EffectGroup* eff_group, f2_struct* st);
bool UnparseEffect(EffectGroup* eff_group, f2_struct* st, Effect* eff);
void UnparseEffectGroup(EffectGroup* eff_group, f2_struct* st);
bool UnparseEmitter(EffectGroup* eff_group, f2_struct* st, Emitter* emit, Effect* eff);
bool UnparseParticle(EffectGroup* eff_group, f2_struct* st, Particle* ptcl, Effect* eff);
bool UnparseEffect(EffectGroup* eff_group, f2_struct* st, Effect* eff, bool big_endian);
void UnparseEffectGroup(EffectGroup* eff_group, f2_struct* st, bool big_endian);
bool UnparseEmitter(EffectGroup* eff_group,
f2_struct* st, Emitter* emit, Effect* eff, bool big_endian);
bool UnparseParticle(EffectGroup* eff_group,
f2_struct* st, Particle* ptcl, Effect* eff, bool big_endian);
static void Write(GLT, EffectGroup* eff_group, const char* path, const char* file, bool compress);
static void Write(GLT, EffectGroup* eff_group,
const char* path, const char* file, bool compress, bool big_endian = false);
};
struct LocusHistory {
@@ -1155,6 +1159,8 @@ namespace Glitter {
vec4 color;
vec3 translation;
float_t scale;
Data();
};
std::vector<Data> data;
@@ -1234,6 +1240,8 @@ namespace Glitter {
int32_t unk0;
int32_t unk1;
Particle::Mesh mesh;
Data();
};
Particle::Data data;
src/CRE/Glitter/locus_history.cpp
+6 -2
View File
@@ -6,6 +6,10 @@
#include "glitter.hpp"
namespace Glitter {
LocusHistory::LocusHistory::Data::Data() :scale() {
}
LocusHistory::LocusHistory(size_t size) {
data.reserve(size);
}
@@ -21,7 +25,7 @@ namespace Glitter {
if (ptcl_inst->data.data.flags & PARTICLE_EMITTER_LOCAL && ptcl_inst->data.emitter) {
vec3 emit_trans;
mat4_get_translation(&ptcl_inst->data.emitter->mat, &emit_trans);
vec3_add(temp, emit_trans, temp);
temp += emit_trans;
}
LocusHistory::Data locus_history;
@@ -57,7 +61,7 @@ namespace Glitter {
if (ptcl_inst->data.data.flags & PARTICLE_EMITTER_LOCAL && ptcl_inst->data.emitter) {
vec3 emit_trans;
mat4_get_translation(&ptcl_inst->data.emitter->mat, &emit_trans);
vec3_add(temp, emit_trans, temp);
temp += emit_trans;
if (ptcl_inst->data.data.flags & PARTICLE_ROTATE_LOCUS)
mat4_mult_vec3(&ptcl_inst->data.emitter->mat_rot, &temp, &temp);
}
src/CRE/Glitter/particle.cpp
+10 -182
View File
@@ -6,6 +6,16 @@
#include "glitter.hpp"
namespace Glitter {
Particle::Data::Data() : flags(), life_time(), life_time_random(), fade_in(), fade_in_random(),
fade_out(), fade_out_random(), type(), pivot(), draw_type(), z_offset(), speed(), speed_random(),
deceleration(), deceleration_random(), reflection_coeff(), reflection_coeff_random(), rebound_plane_y(),
uv_index_type(), uv_index(), frame_step_uv(), uv_index_start(), uv_index_end(), uv_index_count(),
uv_scroll_add_scale(), uv_scroll_2nd_add_scale(), split_u(), split_v(), blend_mode(), mask_blend_mode(),
sub_flags(), count(), locus_history_size(), locus_history_size_random(), draw_flags(),
emission(), tex_hash(), mask_tex_hash(), texture(), mask_texture(), unk0(), unk1(), mesh() {
}
Particle::Particle(GLT) : data() {
version = GLT_VAL == Glitter::X ? 0x05 : 0x03;
data.pivot = PIVOT_MIDDLE_CENTER;
@@ -40,185 +50,3 @@ namespace Glitter {
}
}
/*
#include "particle.hpp"
#include "animation.hpp"
#include "curve.hpp"
static bool glitter_particle_pack_file(GLT, EffectGroup* a1,
f2_struct* st, glitter_particle* a3, glitter_effect* effect);
bool glitter_particle_unparse_file(GLT, EffectGroup* a1,
f2_struct* st, glitter_particle* a3, glitter_effect* effect) {
if (!glitter_particle_pack_file(GLT_VAL, a1, st, a3, effect))
return false;
glitter_curve_type_flags flags = (glitter_curve_type_flags)0;
if (a1->type == Glitter::X)
flags = glitter_particle_x_curve_flags;
else
flags = glitter_particle_curve_flags;
if (a3->data.type != PARTICLE_MESH) {
enum_and(flags, ~CURVE_TYPE_UV_SCROLL_2ND);
if (a3->data.draw_type != DIRECTION_PARTICLE_ROTATION)
enum_and(flags, ~(CURVE_TYPE_ROTATION_X | CURVE_TYPE_ROTATION_Y));
}
f2_struct s;
if (glitter_animation_unparse_file(GLT_VAL, &s, &a3->animation, flags))
st->sub_structs.push_back(s);
return true;
}
static bool glitter_particle_pack_file(GLT,
EffectGroup* a1, f2_struct* st, glitter_particle* a3, glitter_effect* effect) {
size_t l;
size_t d;
glitter_particle_flag flags;
if (a3->version < 2)
return false;
l = 0;
uint32_t o;
enrs e;
enrs_entry ee;
ee = { 0, 1, 204, 1 };
ee.append(0, 51, ENRS_DWORD);
e.vec.push_back(ee);
l += o = 204;
if (a3->version == 3) {
ee = { o, 1, 8, 1 };
ee.append(0, 2, ENRS_DWORD);
e.vec.push_back(ee);
l += o = 8;
}
if (a3->data.type == PARTICLE_LOCUS || a3->data.type == PARTICLE_MESH) {
ee = { o, 1, 4, 1 };
ee.append(0, 2, ENRS_WORD);
e.vec.push_back(ee);
l += o = 4;
}
ee = { o, 4, 44, 1 };
ee.append(0, 1, ENRS_QWORD);
ee.append(4, 5, ENRS_DWORD);
ee.append(0, 2, ENRS_WORD);
ee.append(0, 2, ENRS_DWORD);
if (a1->version >= 7) {
ee.count++;
ee.size += 4;
ee.append.push_back(0, 1, ENRS_DWORD);
e.vec.push_back(ee);
l += o = 48;
}
else {
e.vec.push_back(ee);
l += o = 44;
}
ee = { o, 2, 12, 1 };
ee.append.push_back(0, 1, ENRS_QWORD);
ee.append.push_back(0, 1, ENRS_DWORD);
e.vec.push_back(ee);
l += o = 12;
l = align_val(l, 0x10);
st->data.resize(l);
d = (size_t)st->data.data();
st->enrs = e;
flags = a3->data.flags;
if (effect->data.flags & EFFECT_LOCAL)
enum_and(flags, ~PARTICLE_LOCAL);
if (effect->data.flags & EFFECT_EMISSION)
enum_and(flags, ~PARTICLE_EMISSION);
*(int32_t*)d = a3->data.life_time;
*(int32_t*)(d + 4) = a3->data.type;
*(int32_t*)(d + 8) = a3->data.draw_type;
*(vec3*)(d + 12) = a3->data.rotation;
*(vec3*)(d + 24) = a3->data.rotation_random;
*(vec3*)(d + 36) = a3->data.rotation_add;
*(vec3*)(d + 48) = a3->data.rotation_add_random;
*(vec3*)(d + 60) = a3->data.scale;
*(vec3*)(d + 72) = a3->data.scale_random;
*(float_t*)(d + 84) = a3->data.z_offset;
*(int32_t*)(d + 88) = a3->data.pivot;
*(int32_t*)(d + 92) = flags;
*(float_t*)(d + 96) = a3->data.speed;
*(float_t*)(d + 100) = a3->data.speed_random;
*(float_t*)(d + 104) = a3->data.deceleration;
*(float_t*)(d + 108) = a3->data.deceleration_random;
*(vec3*)(d + 112) = a3->data.direction;
*(vec3*)(d + 124) = a3->data.direction_random;
*(vec3*)(d + 136) = a3->data.gravity;
*(vec3*)(d + 148) = a3->data.acceleration;
*(vec3*)(d + 160) = a3->data.acceleration_random;
*(float_t*)(d + 172) = a3->data.reflection_coeff;
*(float_t*)(d + 176) = a3->data.reflection_coeff_random;
*(float_t*)(d + 180) = a3->data.rebound_plane_y;
*(vec2*)(d + 184) = a3->data.uv_scroll_add;
*(float_t*)(d + 192) = a3->data.uv_scroll_add_scale;
*(int32_t*)(d + 196) = a3->data.sub_flags;
*(int32_t*)(d + 200) = a3->data.count;
d += 204;
if (a3->version == 3) {
*(int32_t*)d = 0;
*(float_t*)(d + 4) = a3->data.emission;
d += 8;
}
if (a3->data.type == PARTICLE_LOCUS || a3->data.type == PARTICLE_MESH) {
*(uint16_t*)d = a3->data.locus_history_size;
*(uint16_t*)(d + 2) = a3->data.locus_history_size_random;
d += 4;
}
*(uint64_t*)d = a3->data.tex_hash;
*(uint8_t*)(d + 8) = (uint8_t)roundf(clamp(a3->data.color.x, 0.0f, 1.0f) * 255.0f);
*(uint8_t*)(d + 9) = (uint8_t)roundf(clamp(a3->data.color.y, 0.0f, 1.0f) * 255.0f);
*(uint8_t*)(d + 10) = (uint8_t)roundf(clamp(a3->data.color.z, 0.0f, 1.0f) * 255.0f);
*(uint8_t*)(d + 11) = (uint8_t)roundf(clamp(a3->data.color.w, 0.0f, 1.0f) * 255.0f);
*(int32_t*)(d + 12) = a3->data.blend_mode;
*(int32_t*)(d + 16) = a3->data.unk0;
*(int32_t*)(d + 20) = a3->data.split_u;
*(int32_t*)(d + 24) = a3->data.split_v;
*(int32_t*)(d + 28) = a3->data.uv_index_type;
*(int16_t*)(d + 32) = a3->data.uv_index;
*(int16_t*)(d + 34) = (int16_t)a3->data.frame_step_uv;
*(int32_t*)(d + 36) = a3->data.uv_index_start;
*(int32_t*)(d + 40) = a3->data.uv_index_end;
if (a1->version >= 7) {
*(int32_t*)(d + 44) = a3->data.unk1;
d += 48;
}
else
d += 44;
if (a3->data.flags & PARTICLE_TEXTURE_MASK) {
*(uint64_t*)d = a3->data.mask_tex_hash;
*(int32_t*)(d + 8) = a3->data.mask_blend_mode;
d += 12;
}
else {
*(uint64_t*)d = 0;
*(int32_t*)(d + 8) = 0;
d += 12;
}
st->header.signature = reverse_endianness_uint32_t('PTCL');
st->header.length = 0x20;
st->header.use_big_endian = false;
st->header.use_section_size = true;
st->header.version = a3->version;
return true;
}
*/
src/CRE/Glitter/particle_inst.cpp
+4 -4
View File
@@ -236,7 +236,7 @@ namespace Glitter {
+ random->F2GetInt(GLT_VAL, ptcl_inst_data->data.uv_index_count);
break;
}
rend_elem->uv_index = min(rend_elem->uv_index, ptcl_inst_data->data.uv_index_end);
rend_elem->uv_index = min_def(rend_elem->uv_index, ptcl_inst_data->data.uv_index_end);
rend_elem->uv.x = (float_t)(rend_elem->uv_index
% ptcl_inst_data->data.split_u) * ptcl_inst_data->data.split_uv.x;
rend_elem->uv.y = (float_t)(rend_elem->uv_index
@@ -559,7 +559,7 @@ namespace Glitter {
float_t time = rend_elem->frame * (float_t)(1.0 / 60.0);
float_t diff_time = time - rend_elem->rebound_time - (float_t)(1.0 / 60.0);
float_t speed = rend_elem->speed * delta_frame;
diff_time = max(diff_time, 0.0f) * (float_t)(1.0 / 60.0);
diff_time = max_def(diff_time, 0.0f) * (float_t)(1.0 / 60.0);
vec3 acceleration;
vec3_mult_scalar(rend_elem->acceleration,
@@ -593,7 +593,7 @@ namespace Glitter {
speed = rend_elem->base_speed + (float_t)(1.0 / 7200.0)
* rend_elem->deceleration - diff_time * rend_elem->deceleration;
rend_elem->speed = max(speed, 0.0f);
rend_elem->speed = max_def(speed, 0.0f);
}
void XParticleInst::Copy(XParticleInst* dst, float_t emission) {
@@ -711,7 +711,7 @@ namespace Glitter {
+ random->XGetInt(ptcl_inst_data->data.uv_index_count);
break;
}
rend_elem->uv_index = min(rend_elem->uv_index, ptcl_inst_data->data.uv_index_end);
rend_elem->uv_index = min_def(rend_elem->uv_index, ptcl_inst_data->data.uv_index_end);
rend_elem->uv.x = (float_t)(rend_elem->uv_index
% ptcl_inst_data->data.split_u) * ptcl_inst_data->data.split_uv.x;
rend_elem->uv.y = (float_t)(rend_elem->uv_index
src/CRE/Glitter/particle_manager.cpp
+4 -4
View File
@@ -761,7 +761,7 @@ namespace Glitter {
id++;
}
CheckSceneHasLocalEffect(j);
SceneCounter counter = j->counter;
if (j->type == Glitter::X)
counter.index = (uint8_t)id;
@@ -789,7 +789,7 @@ namespace Glitter {
}
CheckSceneHasLocalEffect(scene);
scenes.push_back(scene);
if (scene->type == Glitter::X)
counter.index = (uint8_t)id;
return counter;
@@ -922,7 +922,7 @@ namespace Glitter {
break;
}
}
void GltParticleManager::SetSceneFrameRate(SceneCounter scene_counter, FrameRateControl* frame_rate) {
for (Scene*& i : scenes)
if (i && i->counter.counter == scene_counter.counter) {
@@ -930,7 +930,7 @@ namespace Glitter {
break;
}
}
void GltParticleManager::SetSceneName(uint64_t hash, const char* name) {
std::map<uint64_t, EffectGroup*>::iterator elem = effect_groups.find(hash);
if (elem != effect_groups.end())
src/CRE/Glitter/render_element.cpp
+2 -2
View File
@@ -75,7 +75,7 @@ namespace Glitter {
float_t deceleration = random->F2GetFloat(GLT_VAL,
ptcl_inst_data->data.deceleration_random) + ptcl_inst_data->data.deceleration;
this->speed = speed * 60.0f;
this->deceleration = max(deceleration * 60.0f, 0.0f);
this->deceleration = max_def(deceleration * 60.0f, 0.0f);
vec3 acceleration;
random->F2GetVec3(GLT_VAL, ptcl_inst_data->data.acceleration_random, acceleration);
@@ -123,7 +123,7 @@ namespace Glitter {
ptcl_inst_data->data.deceleration_random) + ptcl_inst_data->data.deceleration;
base_speed = speed;
this->speed = speed;
this->deceleration = max(deceleration, 0.0f);
this->deceleration = max_def(deceleration, 0.0f);
vec3 acceleration;
random->XGetVec3(ptcl_inst_data->data.acceleration_random, acceleration);
src/CRE/Glitter/render_group.cpp
+15 -19
View File
@@ -100,8 +100,8 @@ namespace Glitter {
glGenBuffers(1, &ebo);
gl_state_bind_element_array_buffer(ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(int32_t) * count, ebo_data, GL_STATIC_DRAW);;
free(ebo_data);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(int32_t) * count, ebo_data, GL_STATIC_DRAW);
free_def(ebo_data);
}
static const GLsizei buffer_size = sizeof(Buffer);
@@ -214,16 +214,13 @@ namespace Glitter {
particle->AccelerateParticle(GLT_VAL, rend_elem,
rend_elem->frame * (float_t)(1.0 / 60.0), delta_frame, random_ptr);
if (particle->data.data.draw_type == DIRECTION_PARTICLE_ROTATION) {
rend_elem->rotation.x += rend_elem->rotation_add.x * delta_frame;
rend_elem->rotation.y += rend_elem->rotation_add.y * delta_frame;
}
rend_elem->rotation.z += rend_elem->rotation_add.z * delta_frame;
if (particle->data.data.draw_type == DIRECTION_PARTICLE_ROTATION)
rend_elem->rotation += rend_elem->rotation_add * delta_frame;
else
rend_elem->rotation.z += rend_elem->rotation_add.z * delta_frame;
vec2 uv_scroll;
vec2_mult_scalar(particle->data.data.uv_scroll_add,
particle->data.data.uv_scroll_add_scale * delta_frame, uv_scroll);
vec2_add(rend_elem->uv_scroll, uv_scroll, rend_elem->uv_scroll);
rend_elem->uv_scroll += particle->data.data.uv_scroll_add
* (particle->data.data.uv_scroll_add_scale * delta_frame);
particle->StepUVParticle(GLT_VAL, rend_elem, delta_frame, random_ptr);
rend_elem->disp = true;
@@ -453,8 +450,8 @@ namespace Glitter {
glGenBuffers(1, &ebo);
gl_state_bind_element_array_buffer(ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(int32_t) * count, ebo_data, GL_STATIC_DRAW);;
free(ebo_data);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(int32_t) * count, ebo_data, GL_STATIC_DRAW);
free_def(ebo_data);
}
if (!is_mesh) {
@@ -574,11 +571,10 @@ namespace Glitter {
particle->AccelerateParticle(rend_elem, delta_frame, random_ptr);
if (particle->data.data.draw_type == DIRECTION_PARTICLE_ROTATION
|| particle->data.data.type == PARTICLE_MESH) {
rend_elem->rotation.x += rend_elem->rotation_add.x * delta_frame;
rend_elem->rotation.y += rend_elem->rotation_add.y * delta_frame;
}
rend_elem->rotation.z += rend_elem->rotation_add.z * delta_frame;
|| particle->data.data.type == PARTICLE_MESH)
rend_elem->rotation += rend_elem->rotation_add * delta_frame;
else
rend_elem->rotation.z += rend_elem->rotation_add.z * delta_frame;
vec2 uv_scroll;
vec2_mult_scalar(particle->data.data.uv_scroll_add,
@@ -642,7 +638,7 @@ namespace Glitter {
if (!a2 && elements) {
Free();
free(elements);
free_def(elements);
}
}
void XRenderGroup::Emit(XParticleInst::Data* ptcl_inst_data,
src/CRE/Glitter/render_scene.cpp
+7 -9
View File
@@ -485,7 +485,7 @@ namespace Glitter {
RenderElement* elem = rend_group->elements;
size_t disp = 0;
for (size_t i = rend_group->ctrl, j_max = 1024; i > 0; i -= j_max) {
j_max = min(i, j_max);
j_max = min_def(i, j_max);
for (size_t j = j_max; j > 0; elem++) {
if (!elem->alive)
continue;
@@ -639,7 +639,7 @@ namespace Glitter {
size_t disp = 0;
if (rend_group->draw_type == DIRECTION_PARTICLE_ROTATION)
for (size_t i = rend_group->ctrl, j_max = 1024; i > 0; i -= j_max) {
j_max = min(i, j_max);
j_max = min_def(i, j_max);
for (size_t j = j_max; j > 0; elem++) {
if (!elem->alive)
continue;
@@ -722,7 +722,7 @@ namespace Glitter {
}
else
for (size_t i = rend_group->ctrl, j_max = 1024; i > 0; i -= j_max) {
j_max = min(i, j_max);
j_max = min_def(i, j_max);
for (size_t j = j_max; j > 0; elem++) {
if (!elem->alive)
continue;
@@ -1020,7 +1020,6 @@ namespace Glitter {
case PARTICLE_QUAD: {
gl_state_bind_vertex_array(rend_group->vao);
shaders_ft.draw_elements(GL_TRIANGLES, (GLsizei)(6 * rend_group->disp), GL_UNSIGNED_INT, 0);
gl_state_bind_vertex_array(0);
} break;
case PARTICLE_LINE:
@@ -1029,7 +1028,6 @@ namespace Glitter {
const GLenum mode = rend_group->type == PARTICLE_LINE ? GL_LINE_STRIP : GL_TRIANGLE_STRIP;
for (std::pair<GLint, GLsizei>& i : rend_group->draw_list)
shaders_ft.draw_arrays(mode, i.first, i.second);
gl_state_bind_vertex_array(0);
} break;
}
@@ -1457,7 +1455,7 @@ namespace Glitter {
RenderElement* elem = rend_group->elements;
size_t disp = 0;
for (size_t i = rend_group->ctrl, j_max = 1024; i > 0; i -= j_max) {
j_max = min(i, j_max);
j_max = min_def(i, j_max);
for (size_t j = j_max; j > 0; elem++) {
if (!elem->alive)
continue;
@@ -1628,7 +1626,7 @@ namespace Glitter {
RenderElement* elem = rend_group->elements;
size_t disp = 0;
for (size_t i = rend_group->ctrl, j_max = 1024; i > 0; i -= j_max) {
j_max = min(i, j_max);
j_max = min_def(i, j_max);
for (size_t j = j_max; j > 0; elem++) {
if (!elem->alive)
continue;
@@ -1778,7 +1776,7 @@ namespace Glitter {
size_t disp = 0;
if (rend_group->draw_type == DIRECTION_PARTICLE_ROTATION)
for (size_t i = rend_group->ctrl, j_max = 1024; i > 0; i -= j_max) {
j_max = min(i, j_max);
j_max = min_def(i, j_max);
for (size_t j = j_max; j > 0; elem++) {
if (!elem->alive)
continue;
@@ -1856,7 +1854,7 @@ namespace Glitter {
}
else
for (size_t i = rend_group->ctrl, j_max = 1024; i > 0; i -= j_max) {
j_max = min(i, j_max);
j_max = min_def(i, j_max);
for (size_t j = j_max; j > 0; elem++) {
if (!elem->alive)
continue;
src/CRE/Glitter/scene.cpp
+3 -3
View File
@@ -76,7 +76,7 @@ namespace Glitter {
continue;
EffectInst* eff = i.ptr;
bool v13 = false;
bool v14 = false;
if (v14)
@@ -259,7 +259,7 @@ namespace Glitter {
return false;
return true;
}
bool Scene::HasEnded(size_t id, bool a3) {
for (SceneEffect& i : effects)
if (i.ptr && i.disp && i.ptr->id == id && !i.ptr->HasEnded(a3))
@@ -320,7 +320,7 @@ namespace Glitter {
return false;
}
#endif
if (type == Glitter::FT && effect_hash == hash_fnv1a64m_empty
|| type != Glitter::FT && effect_hash == hash_murmurhash_empty) {
for (SceneEffect& i : effects)
src/CRE/auth_3d.cpp
+46 -28
View File
@@ -4,6 +4,7 @@
*/
#include "auth_3d.hpp"
#include "../KKdLib/io/file_stream.hpp"
#include "../KKdLib/io/json.hpp"
#include "../KKdLib/io/path.hpp"
#include "../KKdLib/hash.hpp"
@@ -75,9 +76,9 @@ static int32_t auth_3d_get_auth_3d_object_index_by_hash(auth_3d* auth,
uint32_t object_hash, int32_t instance);
static mat4* auth_3d_get_auth_3d_object_hrc_bone_mats(auth_3d* auth, size_t index);
static int32_t auth_3d_get_auth_3d_object_hrc_index_by_object_info(auth_3d* auth,
object_info obj_info, int32_t instance);
object_info obj_info, int32_t instance = -1);
static int32_t auth_3d_get_auth_3d_object_hrc_index_by_hash(auth_3d* auth,
uint32_t object_hash, int32_t instance);
uint32_t object_hash, int32_t instance = -1);
static void auth_3d_read_file(auth_3d* auth, auth_3d_database* auth_3d_db);
static void auth_3d_read_file_modern(auth_3d* auth);
static void auth_3d_set_material_list(auth_3d* auth, render_context* rctx);
@@ -339,8 +340,8 @@ void auth_3d::ctrl(render_context* rctx) {
auth_3d_post_process_ctrl(&post_process, frame);
auth_3d_post_process_set(&post_process, rctx);
auth_3d_camera_auxiliary_set(&camera_auxiliary, rctx);
auth_3d_camera_auxiliary_ctrl(&camera_auxiliary, frame);
auth_3d_camera_auxiliary_set(&camera_auxiliary, rctx);
if (camera_root_update)
for (auth_3d_camera_root& i : camera_root) {
@@ -1146,7 +1147,7 @@ void auth_3d_light::reset() {
linear_init = 0.0f;
quadratic_init = 0.0f;
specular_init = vec4_null;
tone_curve_init = vec3_null;
tone_curve_init = {};
}
auth_3d_m_object_hrc::auth_3d_m_object_hrc() {
@@ -2303,7 +2304,7 @@ static void a3da_msgpack_read(const char* path, const char* file, a3da* auth_fil
msgpack msg;
stream s;
file_stream s;
s.open(buf, "rb");
io_json_read(s, &msg);
s.close();
@@ -2311,9 +2312,9 @@ static void a3da_msgpack_read(const char* path, const char* file, a3da* auth_fil
if (msg.type != MSGPACK_MAP)
return;
msgpack* m_objhrcs = msg.read("m_objhrc");
msgpack* m_objhrcs = msg.read_array("m_objhrc");
if (m_objhrcs) {
msgpack_array* ptr = MSGPACK_SELECT_PTR(msgpack_array, m_objhrcs);
msgpack_array* ptr = m_objhrcs->data.arr;
for (msgpack& i : *ptr) {
msgpack& m_objhrc = i;
@@ -2324,9 +2325,9 @@ static void a3da_msgpack_read(const char* path, const char* file, a3da* auth_fil
if (name_hash != hash_string_murmurhash(j.name))
continue;
msgpack* instances = m_objhrc.read("instance");
msgpack* instances = m_objhrc.read_array("instance");
if (instances) {
msgpack_array* ptr = MSGPACK_SELECT_PTR(msgpack_array, instances);
msgpack_array* ptr = instances->data.arr;
for (msgpack& k : *ptr) {
msgpack& instance = k;
@@ -2340,9 +2341,9 @@ static void a3da_msgpack_read(const char* path, const char* file, a3da* auth_fil
}
}
msgpack* objhrcs = msg.read("objhrc");
msgpack* objhrcs = msg.read_array("objhrc");
if (objhrcs) {
msgpack_array* ptr = MSGPACK_SELECT_PTR(msgpack_array, objhrcs);
msgpack_array* ptr = objhrcs->data.arr;
for (msgpack& i : *ptr) {
msgpack& objhrc = i;
@@ -2364,7 +2365,7 @@ static bool auth_3d_key_detect_fast_change(auth_3d_key* data, float_t frame, flo
if (data->type < AUTH_3D_KEY_LINEAR || data->type > AUTH_3D_KEY_HOLD)
return false;
frame = clamp(frame, 0.0f, data->max_frame);
frame = clamp_def(frame, 0.0f, data->max_frame);
size_t length = data->length;
if (!length)
return false;
@@ -2622,25 +2623,39 @@ static mat4* auth_3d_get_auth_3d_object_hrc_bone_mats(auth_3d* auth, size_t inde
static int32_t auth_3d_get_auth_3d_object_hrc_index_by_object_info(auth_3d* auth,
object_info obj_info, int32_t instance) {
int32_t obj_instance = 0;
for (auth_3d_object_hrc& i : auth->object_hrc)
if (obj_info == i.object_info) {
if (obj_instance == instance)
if (instance < 0) {
for (auth_3d_object_hrc& i : auth->object_hrc)
if (obj_info == i.object_info)
return (int32_t)(&i - auth->object_hrc.data());
obj_instance++;
}
}
else {
int32_t obj_instance = 0;
for (auth_3d_object_hrc& i : auth->object_hrc)
if (obj_info == i.object_info) {
if (obj_instance == instance)
return (int32_t)(&i - auth->object_hrc.data());
obj_instance++;
}
}
return -1;
}
static int32_t auth_3d_get_auth_3d_object_hrc_index_by_hash(auth_3d* auth,
uint32_t object_hash, int32_t instance) {
int32_t obj_instance = 0;
for (auth_3d_object_hrc& i : auth->object_hrc)
if (object_hash == i.object_hash) {
if (obj_instance == instance)
if (instance < 0) {
for (auth_3d_object_hrc& i : auth->object_hrc)
if (object_hash == i.object_hash)
return (int32_t)(&i - auth->object_hrc.data());
obj_instance++;
}
}
else {
int32_t obj_instance = 0;
for (auth_3d_object_hrc& i : auth->object_hrc)
if (object_hash == i.object_hash) {
if (obj_instance == instance)
return (int32_t)(&i - auth->object_hrc.data());
obj_instance++;
}
}
return -1;
}
@@ -2954,8 +2969,7 @@ static void auth_3d_dof_set(auth_3d_dof* d, render_context* rctx) {
vec3 view_point;
rctx->camera->get_view_point(view_point);
float_t focus;
vec3_distance(d->model_transform.translation_value, view_point, focus);
float_t focus = vec3::distance(d->model_transform.translation_value, view_point);
dof_pv pv;
pv.enable = fabsf(d->model_transform.rotation_value.z) > 0.000001f;
@@ -3281,7 +3295,11 @@ static void auth_3d_light_set(auth_3d_light* l, render_context* rctx) {
enum_or(l->flags_init, AUTH_3D_LIGHT_TONE_CURVE);
}
data->set_tone_curve(*(vec3*)&l->tone_curve.value);
light_tone_curve tone_curve;
tone_curve.start_point = l->tone_curve.value.x;
tone_curve.end_point = l->tone_curve.value.y;
tone_curve.coefficient = l->tone_curve.value.z;
data->set_tone_curve(tone_curve);
}
}
@@ -4679,7 +4697,7 @@ static void Auth3dTestTask__SetStage(Auth3dTestTask* tt) {
if (!v7)
break;
if (memcmp(v7, "STG", min(v5, 3))) {
if (memcmp(v7, "STG", min_def(v5, 3))) {
v5 += v6 - v7 - 1;
v6 = v7 + 1;
continue;
src/CRE/auth_3d.hpp
+3 -3
View File
@@ -430,7 +430,7 @@ struct auth_3d_light {
float_t linear_init;
float_t quadratic_init;
vec4 specular_init;
vec3 tone_curve_init;
light_tone_curve tone_curve_init;
auth_3d_light();
~auth_3d_light();
@@ -852,9 +852,9 @@ extern bool auth_3d_data_check_id_loaded(int32_t* id);
extern auth_3d* auth_3d_data_get_auth_3d(int32_t id);
extern int32_t auth_3d_data_get_auth_3d_id(const char* object_name);
extern int32_t auth_3d_data_get_auth_3d_id(object_info obj_info,
int32_t* object_index, bool* hrc, int32_t instance);
int32_t* object_index, bool* hrc, int32_t instance = -1);
extern int32_t auth_3d_data_get_auth_3d_id(uint32_t file_name_hash, uint32_t object_hash,
int32_t* object_index, bool* hrc, int32_t instance);
int32_t* object_index, bool* hrc, int32_t instance = -1);
extern mat4* auth_3d_data_get_auth_3d_object_mat(int32_t id, size_t index, bool hrc, mat4* mat);
extern int32_t auth_3d_data_get_chara_id(int32_t id);
extern bool auth_3d_data_get_enable(int32_t* id);
src/CRE/camera.cpp
+88 -50
View File
@@ -6,14 +6,14 @@
#include "camera.hpp"
static void camera_calculate_projection(camera* c);
static void camera_calculate_projection_aet(camera* c);
static void camera_calculate_view(camera* c);
static void camera_calculate_forward(camera* c);
camera::camera() : view(), inv_view(), projection(), inv_projection(), view_projection(),
inv_view_projection(), view_projection_prev(), inv_view_projection_prev(), view_mat3(), inv_view_mat3(),
view_rot(), inv_view_rot(), forward(), rotation(), view_point(), interest(), width(), height(), field_1E4(),
field_1F0(), field_1FC(), field_208(), yaw(), pitch(), roll(), aspect(), fov(), fov_rad(),max_distance(),
min_distance(), changed_view(), changed_proj(), fast_change(), fast_change_hist0(), fast_change_hist1() {
camera::camera() : forward(), rotation(), view_point(), interest(), render_width(), render_height(),
sprite_width(), sprite_height(), field_1E4(), field_1F0(), field_1FC(), field_208(), yaw(),
pitch(), roll(), aspect(), fov(), fov_rad(), max_distance(), min_distance(), changed_view(),
changed_proj(), changed_proj_aet(), fast_change(), fast_change_hist0(), fast_change_hist1() {
}
@@ -21,15 +21,18 @@ camera::~camera() {
}
void camera::initialize(double_t aspect, int32_t width, int32_t height) {
void camera::initialize(double_t aspect, int32_t render_width,
int32_t render_height, int32_t sprite_width, int32_t sprite_height) {
this->aspect = aspect;
fov = 0.0;
forward = { 0.0f, 0.0f, -1.0f };
rotation = { 0.0f, 0.0f, 0.0f };
view_point = { 0.0, 0.0f, 0.0f };
interest = { 0.0f, 0.0f, -1.0f };
this->width = width;
this->height = height;
this->render_width = render_width;
this->render_height = render_height;
this->sprite_width = sprite_width;
this->sprite_height = sprite_height;
view = mat4_identity;
inv_view = mat4_identity;
projection = mat4_identity;
@@ -41,6 +44,7 @@ void camera::initialize(double_t aspect, int32_t width, int32_t height) {
min_distance = 0.05;
max_distance = 6000.0;
changed_proj = true;
changed_proj_aet = true;
changed_view = true;
fast_change = false;
fast_change_hist0 = false;
@@ -62,6 +66,7 @@ void camera::set_min_distance(double_t value) {
if (value != min_distance) {
min_distance = value;
changed_proj = true;
changed_proj_aet = true;
}
}
@@ -92,7 +97,7 @@ double_t camera::get_fov() {
}
void camera::set_fov(double_t value) {
value = clamp(value, 1.0, 180.0);
value = clamp_def(value, 1.0, 180.0);
if (value != fov) {
fov = value;
fov_rad = value * DEG_TO_RAD;
@@ -106,7 +111,7 @@ double_t camera::get_pitch() {
void camera::set_pitch(double_t value) {
value = fmod(value, 360.0);
value = clamp(value, -89.5, 89.5);
value = clamp_def(value, -89.5, 89.5);
if (pitch != value) {
pitch = value;
changed_view = true;
@@ -173,16 +178,24 @@ void camera::set_interest(const vec3&& value) {
}
}
void camera::get_res(int32_t& width, int32_t& height) {
width = this->width;
height = this->height;
void camera::get_res(int32_t& render_width, int32_t& render_height,
int32_t& sprite_width, int32_t& sprite_height) {
render_width = this->render_width;
render_height = this->render_height;
sprite_width = this->sprite_width;
sprite_height = this->sprite_height;
}
void camera::set_res(int32_t width, int32_t height) {
if (this->width != width || this->height != height) {
this->width = width;
this->height = height;
void camera::set_res(int32_t render_width, int32_t render_height,
int32_t sprite_width, int32_t sprite_height) {
if (this->render_width != render_width || this->render_height != render_height
|| this->sprite_width != sprite_width || this->sprite_height != sprite_height) {
this->render_width = render_width;
this->render_height = render_height;
this->sprite_width = sprite_width;
this->sprite_height = sprite_height;
changed_proj = true;
changed_proj_aet = true;
}
}
@@ -215,20 +228,12 @@ void camera::reset() {
void camera::move(double_t move_x, double_t move_y) {
if (move_x != 0.0 || move_y != 0.0) {
vec3 temp;
vec3 view_point;
vec3 interest;
vec3 up = { 0.0f, 1.0f, 0.0f };
vec3_cross(forward, up, temp);
vec3_normalize(temp, temp);
vec3_mult_scalar(temp, (float_t)move_y, temp);
vec3_add(this->view_point, temp, view_point);
vec3_mult_scalar(forward, (float_t)move_x, temp);
vec3_add(view_point, temp, view_point);
vec3_add(view_point, forward, interest);
vec3 view_point = this->view_point;
view_point += vec3::normalize(vec3::cross(forward, up)) * (float_t)move_y;
view_point += forward * (float_t)move_x;
set_view_point(view_point);
set_interest(interest);
set_interest(view_point + forward);
}
}
@@ -242,9 +247,7 @@ void camera::rotate(double_t rotate_x, double_t rotate_y) {
if (rotate_x != 0.0 || rotate_y != 0.0) {
camera_calculate_forward(this);
vec3 interest;
vec3_add(view_point, forward, interest);
set_interest(interest);
set_interest(view_point + forward);
}
}
@@ -279,17 +282,13 @@ void camera::set(const vec3&& view_point, const vec3&& interest,
}
void camera::set_position(const vec3& pos) {
vec3 interest;
vec3_add(pos, forward, interest);
set_view_point(pos);
set_interest(interest);
set_interest(pos + forward);
}
void camera::set_position(const vec3&& pos) {
vec3 interest;
vec3_add(pos, forward, interest);
set_view_point(pos);
set_interest(interest);
set_interest(pos + forward);
}
void camera::update() {
@@ -304,6 +303,9 @@ void camera::update_data() {
if (changed_proj)
camera_calculate_projection(this);
if (changed_proj_aet)
camera_calculate_projection_aet(this);
if (changed_view)
camera_calculate_view(this);
@@ -313,6 +315,7 @@ void camera::update_data() {
}
changed_proj = false;
changed_proj_aet = false;
changed_view = false;
}
@@ -326,31 +329,67 @@ static void camera_calculate_projection(camera* c) {
mat4_persp(c->fov_rad, c->aspect, c->min_distance, c->max_distance, &c->projection);
mat4_inverse(&c->projection, &c->inv_projection);
float_t fov_correct_height = (float_t)(((double_t)c->height * 0.5) / tan(c->fov_rad * 0.5));
float_t height = (float_t)c->height * 0.5f;
float_t width = (float_t)c->height * (float_t)c->aspect * 0.5f;
float_t fov_correct_height = (float_t)(((double_t)c->render_height * 0.5) / tan(c->fov_rad * 0.5));
float_t height = (float_t)c->render_height * 0.5f;
float_t width = (float_t)c->render_height * (float_t)c->aspect * 0.5f;
c->field_1E4.x = fov_correct_height;
c->field_1E4.y = 0.0f;
c->field_1E4.z = -width;
vec3_normalize(c->field_1E4, c->field_1E4);
c->field_1E4 = vec3::normalize(c->field_1E4);
c->field_1F0.x = -fov_correct_height;
c->field_1F0.y = 0.0f;
c->field_1F0.z = -width;
vec3_normalize(c->field_1F0, c->field_1F0);
c->field_1F0 = vec3::normalize(c->field_1F0);
c->field_1FC.x = 0.0f;
c->field_1FC.y = fov_correct_height;
c->field_1FC.z = -height;
vec3_normalize(c->field_1FC, c->field_1FC);
c->field_1FC = vec3::normalize(c->field_1FC);
c->field_208.x = 0.0f;
c->field_208.y = -fov_correct_height;
c->field_208.z = -height;
vec3_normalize(c->field_208, c->field_208);
c->field_208 = vec3::normalize(c->field_208);
}
static void camera_calculate_projection_aet(camera* c) {
float_t sprite_half_width = (float_t)c->sprite_width * 0.5f;
float_t sprite_half_height = (float_t)c->sprite_height * 0.5f;
float_t render_half_width = (float_t)c->render_width * 0.5f;
float_t render_half_height = (float_t)c->render_height * 0.5f;
float_t aet_depth = sprite_half_height / (tanf(0.34557518363f) * 0.75f);
float_t v8a = (float_t)c->min_distance / aet_depth * sprite_half_width;
float_t v8b = (float_t)c->min_distance / aet_depth * sprite_half_height;
mat4 spr_2d_proj;
mat4_frustrum(-v8a, v8a, v8b, -v8b, c->min_distance, 3000.0, &spr_2d_proj);
vec3 spr_2d_viewpoint = { sprite_half_width, sprite_half_height, aet_depth };
vec3 spr_2d_interest = { sprite_half_width, sprite_half_height, 0.0f };
vec3 spr_2d_up = { 0.0f, 1.0f, 0.0f };
mat4 spr_2d_view;
mat4_look_at(&spr_2d_viewpoint, &spr_2d_interest, &spr_2d_up, &spr_2d_view);
mat4_mult(&spr_2d_view, &spr_2d_proj, &c->projection_aet_2d);
float_t v13a = (float_t)c->min_distance / aet_depth * render_half_width;
float_t v13b = (float_t)c->min_distance / aet_depth * render_half_height;
mat4 spr_3d_proj;
mat4_frustrum(-v13a, v13a, v13b, -v13b, c->min_distance, 3000.0, &spr_3d_proj);
vec3 spr_3d_viewpoint = { render_half_width, render_half_height, render_half_height };
vec3 spr_3d_interest = { render_half_width, render_half_height, 0.0f };
vec3 spr_3d_up = { 0.0f, 1.0f, 0.0f };
mat4 spr_3d_view;
mat4_look_at(&spr_3d_viewpoint, &spr_3d_interest, &spr_3d_up, &spr_3d_view);
mat4_mult(&spr_3d_view, &spr_3d_proj, &c->projection_aet_3d);
}
static void camera_calculate_view(camera* c) {
vec3 direction;
vec3_sub(c->view_point, c->interest, direction);
vec3 direction = c->view_point - c->interest;
vec3 rotation;
rotation.x = atan2f(-direction.y, sqrtf(direction.x * direction.x + direction.z * direction.z));
@@ -358,10 +397,9 @@ static void camera_calculate_view(camera* c) {
rotation.z = (float_t)(c->roll * DEG_TO_RAD);
c->rotation = rotation;
vec3_negate(rotation, rotation);
rotation = -rotation;
vec3 view_point;
vec3_negate(c->view_point, view_point);
vec3 view_point = -c->view_point;
mat4_rotate_z(rotation.z, &c->view);
mat4_rotate_x_mult(&c->view, rotation.x, &c->view);
src/CRE/camera.hpp
+13 -5
View File
@@ -22,12 +22,16 @@ struct camera {
mat3 inv_view_mat3;
mat4 view_rot;
mat4 inv_view_rot;
mat4 projection_aet_2d;
mat4 projection_aet_3d;
vec3 forward;
vec3 rotation;
vec3 view_point;
vec3 interest;
int32_t width;
int32_t height;
int32_t render_width;
int32_t render_height;
int32_t sprite_width;
int32_t sprite_height;
vec3 field_1E4;
vec3 field_1F0;
vec3 field_1FC;
@@ -42,6 +46,7 @@ struct camera {
double_t min_distance;
bool changed_view;
bool changed_proj;
bool changed_proj_aet;
bool fast_change;
bool fast_change_hist0;
bool fast_change_hist1;
@@ -49,7 +54,8 @@ struct camera {
camera();
virtual ~camera();
void initialize(double_t aspect, int32_t width, int32_t height);
void initialize(double_t aspect, int32_t render_width, int32_t render_height,
int32_t sprite_width, int32_t sprite_height);
double_t get_min_distance();
void set_min_distance(double_t value);
double_t get_max_distance();
@@ -70,8 +76,10 @@ struct camera {
void get_interest(vec3& value);
void set_interest(const vec3& value);
void set_interest(const vec3&& value);
void get_res(int32_t& width, int32_t& height);
void set_res(int32_t width, int32_t height);
void get_res(int32_t& render_width, int32_t& render_height,
int32_t& sprite_width, int32_t& sprite_height);
void set_res(int32_t render_width, int32_t render_height,
int32_t sprite_width, int32_t sprite_height);
void set_fast_change(bool value);
void set_fast_change_hist0(bool value);
void set_fast_change_hist1(bool value);
src/CRE/data.cpp
+125 -276
View File
@@ -4,8 +4,9 @@
*/
#include "data.hpp"
#include "../KKdLib/io/file_stream.hpp"
#include "../KKdLib/io/memory_stream.hpp"
#include "../KKdLib/io/path.hpp"
#include "../KKdLib/io/stream.hpp"
#include "../KKdLib/hash.hpp"
#include "../KKdLib/str_utils.hpp"
#include "mdata_manager.hpp"
@@ -27,26 +28,30 @@ void data_struct_init() {
}
void data_struct_load(const char* path) {
stream s;
file_stream s;
s.open(path, "rb");
if (s.io.stream)
if (s.check_not_null())
data_load_inner(s);
else {
s.close();
s.open(default_config, 7);
data_load_inner(s);
memory_stream ms;
ms.open(default_config, 7);
data_load_inner(ms);
}
}
void data_struct_load(const wchar_t* path) {
stream s;
file_stream s;
s.open(path, L"rb");
if (s.io.stream)
if (s.check_not_null())
data_load_inner(s);
else {
s.close();
s.open(default_config, 7);
data_load_inner(s);
memory_stream ms;
ms.open(default_config, 7);
data_load_inner(ms);
}
}
@@ -93,6 +98,16 @@ void data_struct_load_db() {
d->obj_db.add(&obj_db_file);
}
for (std::string& i : prefixes) {
std::string file = i + "spr_db.bin";
sprite_database_file spr_db_file;
spr_db_file.modern = false;
ds->load_file(&spr_db_file, "rom/2d/", file.c_str(),
sprite_database_file::load_file);
d->spr_db.add(&spr_db_file);
}
for (std::string& i : prefixes) {
std::string file = i + "stage_data.bin";
@@ -247,39 +262,22 @@ bool data_struct::check_directory_exists(const char* dir) {
dir_len--;
}
size_t max_len = 0;
for (data_struct_path& i : data_paths)
for (data_struct_directory& j : i.data)
if (max_len < j.path.size())
max_len = j.path.size();
std::string dir_temp(dir, dir_len);
char* dir_temp = force_malloc_s(char, dir_len + 1);
memcpy(dir_temp, dir, dir_len + 1);
char* t = dir_temp;
char* t = (char*)dir_temp.c_str();
while (t = strchr(t, '/'))
*t = '\\';
char* temp = force_malloc_s(char, max_len + dir_len + 2);
std::string temp;
for (data_struct_path& i : data_paths)
for (data_struct_directory& j : i.data) {
const char* path = j.path.c_str();
size_t path_len = j.path.size();
temp.assign(j.path);
temp += '\\';
temp.append(dir_temp);
memcpy(temp, path, path_len);
memcpy(&temp[path_len], "\\", 2);
if (dir_len)
memcpy(&temp[path_len + 1], dir_temp, dir_len + 1);
if (path_check_directory_exists(temp)) {
free(dir_temp);
free(temp);
if (path_check_directory_exists(temp.c_str()))
return true;
}
}
free(dir_temp);
free(temp);
return false;
}
@@ -339,44 +337,24 @@ bool data_struct::check_file_exists(const char* dir, const char* file) {
dir_len--;
}
size_t max_len = 0;
for (data_struct_path& i : data_paths)
for (data_struct_directory& j : i.data)
if (max_len < j.path.size())
max_len = j.path.size();
std::string dir_temp(dir, dir_len);
char* dir_temp = force_malloc_s(char, dir_len + 1);
memcpy(dir_temp, dir, dir_len + 1);
char* t = dir_temp;
char* t = (char*)dir_temp.c_str();
while (t = strchr(t, '/'))
*t = '\\';
char* temp = force_malloc_s(char, max_len + dir_len + file_len + 2);
std::string temp;
for (data_struct_path& i : data_paths)
for (data_struct_directory& j : i.data) {
const char* path = j.path.c_str();
size_t path_len = j.path.size();
temp.assign(j.path);
temp += '\\';
temp.append(dir_temp);
temp.append(file, file_len);
memcpy(temp, path, path_len);
memcpy(&temp[path_len], "\\", 2);
if (dir_len) {
memcpy(&temp[path_len + 1], dir_temp, dir_len + 1);
memcpy(&temp[path_len + dir_len + 1], file, file_len + 1);
}
else
memcpy(&temp[path_len + 1], file, file_len + 1);
if (path_check_file_exists(temp)) {
free(dir_temp);
free(temp);
if (path_check_file_exists(temp.c_str()))
return true;
}
}
free(dir_temp);
free(temp);
if (f2)
return check_file_exists("rom/data/", file);
return false;
@@ -407,32 +385,20 @@ bool data_struct::check_file_exists(const char* dir, uint32_t hash) {
dir_len--;
}
size_t max_len = 0;
for (data_struct_path& i : data_paths)
for (data_struct_directory& j : i.data)
if (max_len < j.path.size())
max_len = j.path.size();
std::string dir_temp(dir, dir_len);
char* dir_temp = force_malloc_s(char, dir_len + 1);
memcpy(dir_temp, dir, dir_len + 1);
char* t = dir_temp;
char* t = (char*)dir_temp.c_str();
while (t = strchr(t, '/'))
*t = '\\';
char* temp = force_malloc_s(char, max_len + dir_len + 2);
std::string temp;
for (data_struct_path& i : data_paths)
for (data_struct_directory& j : i.data) {
const char* path = j.path.c_str();
size_t path_len = j.path.size();
temp.assign(j.path);
temp += '\\';
temp.append(dir_temp);
memcpy(temp, path, path_len);
memcpy(&temp[path_len], "\\", 2);
if (dir_len)
memcpy(&temp[path_len + 1], dir_temp, dir_len + 1);
std::vector<std::string> files;
path_get_files(&files, temp);
std::vector<std::string> files = path_get_files(temp.c_str());
if (!files.size())
continue;
@@ -449,16 +415,10 @@ bool data_struct::check_file_exists(const char* dir, uint32_t hash) {
}
for (uint32_t& l : files_murmurhash)
if (l == hash) {
free(dir_temp);
free(temp);
if (l == hash)
return true;
}
}
free(dir_temp);
free(temp);
if (f2)
return check_file_exists("rom/data/", hash);
return false;
@@ -492,32 +452,20 @@ void data_struct::get_directory_files(const char* dir, std::vector<data_struct_f
dir_len--;
}
size_t max_len = 0;
for (data_struct_path& i : data_paths)
for (data_struct_directory& j : i.data)
if (max_len < j.path.size())
max_len = j.path.size();
std::string dir_temp(dir, dir_len);
char* dir_temp = force_malloc_s(char, dir_len + 1);
memcpy(dir_temp, dir, dir_len + 1);
char* t = dir_temp;
char* t = (char*)dir_temp.c_str();
while (t = strchr(t, '/'))
*t = '\\';
char* temp = force_malloc_s(char, max_len + dir_len + 2);
std::string temp;
for (data_struct_path& i : data_paths)
for (data_struct_directory& j : i.data) {
const char* path = j.path.c_str();
size_t path_len = j.path.size();
temp.assign(j.path);
temp += '\\';
temp.append(dir_temp);
memcpy(temp, path, path_len);
memcpy(&temp[path_len], "\\", 2);
if (dir_len)
memcpy(&temp[path_len + 1], dir_temp, dir_len + 1);
std::vector<std::string> files;
path_get_files(&files, temp);
std::vector<std::string> files = path_get_files(temp.c_str());
if (!files.size())
continue;
@@ -533,14 +481,11 @@ void data_struct::get_directory_files(const char* dir, std::vector<data_struct_f
continue;
data_struct_file f;
f.path = temp;
f.name = k;
f.path.assign(temp);
f.name.assign(k);
data_files.push_back(f);
}
}
free(dir_temp);
free(temp);
}
bool data_struct::get_file(const char* dir, uint32_t hash, const char* ext, std::string& file) {
@@ -568,32 +513,20 @@ bool data_struct::get_file(const char* dir, uint32_t hash, const char* ext, std:
dir_len--;
}
size_t max_len = 0;
for (data_struct_path& i : data_paths)
for (data_struct_directory& j : i.data)
if (max_len < j.path.size())
max_len = j.path.size();
std::string dir_temp(dir, dir_len);
char* dir_temp = force_malloc_s(char, dir_len + 1);
memcpy(dir_temp, dir, dir_len + 1);
char* t = dir_temp;
char* t = (char*)dir_temp.c_str();
while (t = strchr(t, '/'))
*t = '\\';
char* temp = force_malloc_s(char, max_len + dir_len + 2);
std::string temp;
for (data_struct_path& i : data_paths)
for (data_struct_directory& j : i.data) {
const char* path = j.path.c_str();
size_t path_len = j.path.size();
temp.assign(j.path);
temp += '\\';
temp.append(dir_temp);
memcpy(temp, path, path_len);
memcpy(&temp[path_len], "\\", 2);
if (dir_len)
memcpy(&temp[path_len + 1], dir_temp, dir_len + 1);
std::vector<std::string> files;
path_get_files(&files, temp);
std::vector<std::string> files = path_get_files(temp.c_str());
if (!files.size())
continue;
@@ -608,17 +541,12 @@ bool data_struct::get_file(const char* dir, uint32_t hash, const char* ext, std:
t = l.c_str();
if (hash_murmurhash(t, t_len) == hash) {
file = l;
free(dir_temp);
free(temp);
file.assign(l);
return true;
}
}
}
free(dir_temp);
free(temp);
if (f2)
return get_file("rom/data/", hash, ext, file);
return false;
@@ -682,39 +610,22 @@ bool data_struct::load_file(void* data, const char* dir, const char* file,
dir_len--;
}
size_t max_len = 0;
for (data_struct_path& i : data_paths)
for (data_struct_directory& j : i.data)
if (max_len < j.path.size())
max_len = j.path.size();
std::string dir_temp(dir, dir_len);
char* dir_temp = force_malloc_s(char, dir_len + 1);
memcpy(dir_temp, dir, dir_len + 1);
char* t = dir_temp;
char* t = (char*)dir_temp.c_str();
while(t = strchr(t, '/'))
*t = '\\';
char* temp = force_malloc_s(char, max_len + dir_len + file_len + 2);
std::string temp;
for (data_struct_path& i : data_paths)
for (data_struct_directory& j : i.data) {
const char* path = j.path.c_str();
size_t path_len = j.path.size();
temp.assign(j.path);
temp += '\\';
temp.append(dir_temp);
temp.append(file, file_len);
memcpy(temp, path, path_len);
memcpy(&temp[path_len], "\\", 2);
if (dir_len) {
memcpy(&temp[path_len + 1], dir_temp, dir_len + 1);
memcpy(&temp[path_len + dir_len + 1], file, file_len + 1);
}
else
memcpy(&temp[path_len + 1], file, file_len + 1);
if (path_check_file_exists(temp)) {
if (dir_len)
temp[path_len + dir_len + 1] = 0;
else
temp[path_len + 1] = 0;
if (path_check_file_exists(temp.c_str())) {
temp.resize(temp.size() - file_len);
const char* l_str = file;
const char* t = strrchr(l_str, '.');
@@ -725,17 +636,11 @@ bool data_struct::load_file(void* data, const char* dir, const char* file,
l_len = file_len;
uint32_t h = hash_murmurhash(l_str, l_len);
if (load_func(data, temp, l_str, h)) {
free(dir_temp);
free(temp);
if (load_func(data, temp.c_str(), l_str, h))
return true;
}
}
}
free(dir_temp);
free(temp);
if (f2)
return load_file(data, "rom/data/", file, load_func);
return false;
@@ -767,32 +672,20 @@ bool data_struct::load_file(void* data, const char* dir, uint32_t hash, const ch
dir_len--;
}
size_t max_len = 0;
for (data_struct_path& i : data_paths)
for (data_struct_directory& j : i.data)
if (max_len < j.path.size())
max_len = j.path.size();
std::string dir_temp(dir, dir_len);
char* dir_temp = force_malloc_s(char, dir_len + 1);
memcpy(dir_temp, dir, dir_len + 1);
char* t = dir_temp;
char* t = (char*)dir_temp.c_str();
while (t = strchr(t, '/'))
*t = '\\';
char* temp = force_malloc_s(char, max_len + dir_len + 2);
std::string temp;
for (data_struct_path& i : data_paths)
for (data_struct_directory& j : i.data) {
const char* path = j.path.c_str();
size_t path_len = j.path.size();
temp.assign(j.path);
temp += '\\';
temp.append(dir_temp);
memcpy(temp, path, path_len);
memcpy(&temp[path_len], "\\", 2);
if (dir_len)
memcpy(&temp[path_len + 1], dir_temp, dir_len + 1);
std::vector<std::string> files;
path_get_files(&files, temp);
std::vector<std::string> files = path_get_files(temp.c_str());
if (!files.size())
continue;
@@ -807,17 +700,11 @@ bool data_struct::load_file(void* data, const char* dir, uint32_t hash, const ch
t = l.c_str();
if (hash_murmurhash(t, t_len) == hash
&& load_func(data, temp, l.c_str(), hash)) {
free(dir_temp);
free(temp);
&& load_func(data, temp.c_str(), l.c_str(), hash))
return true;
}
}
}
free(dir_temp);
free(temp);
if (f2)
return load_file(data, "rom/data/", hash, ext, load_func);
return false;
@@ -918,11 +805,11 @@ static void data_load_inner(stream& s) {
char* buf;
char** lines;
size_t count;
if (!str_utils_text_file_parse(data, length, &buf, &lines, &count)) {
free(data);
if (!str_utils_text_file_parse(data, length, buf, lines, count)) {
free_def(data);
return;
}
free(data);
free_def(data);
for (size_t i = 0; i < count; i++) {
char* s = lines[i];
@@ -1002,36 +889,15 @@ static void data_load_inner(stream& s) {
count++;
}
size_t max_len = 0;
t = data_paths;
for (size_t j = 0; j < count; j++) {
size_t len = utf8_length(t);
if (max_len < len)
max_len = len;
t += len + 1;
}
size_t main_rom_len = utf8_length(main_rom);
size_t add_data_len = utf8_length(add_data);
size_t add_data_rom_len = utf8_length(add_data_rom);
char* main_rom_path = force_malloc_s(char, max_len + main_rom_len + 3);
if (!main_rom_path) {
data_free_inner(ds);
continue;
}
char* add_data_rom_path = force_malloc_s(char, max_len + add_data_len + 3);
if (!add_data_rom_path) {
free(main_rom_path);
data_free_inner(ds);
continue;
}
std::string main_rom_path;
std::string add_data_rom_path;
ssize_t* t_len = force_malloc_s(ssize_t, count);
if (!t_len) {
free(main_rom_path);
free(add_data_rom_path);
data_free_inner(ds);
continue;
}
@@ -1048,94 +914,77 @@ static void data_load_inner(stream& s) {
data_path.data = {};
ds->data_paths.push_back(data_path);
}
free(t_len);
free_def(t_len);
for (data_struct_path& j : ds->data_paths) {
const char* data_path = j.path.c_str();
size_t data_path_length = j.path.size();
if (!main_rom_len)
memcpy(main_rom_path, data_path, data_path_length);
main_rom_path.assign(j.path);
else if (data_path_length) {
memcpy(main_rom_path, data_path, data_path_length);
main_rom_path[data_path_length] = '\\';
memcpy(&main_rom_path[data_path_length + 1], main_rom, main_rom_len + 1);
main_rom_path.assign(j.path);
main_rom_path += '\\';
main_rom_path.append(main_rom, main_rom_len);
}
else
memcpy(main_rom_path, main_rom, main_rom_len + 1);
main_rom_path.assign(main_rom, main_rom_len);
if (!add_data_len)
memcpy(add_data_rom_path, data_path, data_path_length);
add_data_rom_path.assign(j.path);
else if (data_path_length) {
memcpy(add_data_rom_path, data_path, data_path_length);
add_data_rom_path[data_path_length] = '\\';
memcpy(&add_data_rom_path[data_path_length + 1], add_data, add_data_len + 1);
add_data_rom_path.assign(j.path);
add_data_rom_path += '\\';
add_data_rom_path.append(add_data, add_data_len);
}
else
memcpy(add_data_rom_path, add_data, add_data_len + 1);
add_data_rom_path.assign(add_data, add_data_len);
size_t main_rom_path_len = utf8_length(main_rom_path);
if (main_rom_path_len && main_rom_path[main_rom_path_len - 1] == '\\') {
main_rom_path[main_rom_path_len - 1] = 0;
main_rom_path_len--;
}
if (main_rom_path.size() && main_rom_path.back() == '\\')
main_rom_path.pop_back();
size_t add_data_rom_path_len = utf8_length(add_data_rom_path);
if (add_data_rom_path_len && add_data_rom_path[add_data_rom_path_len - 1] == '\\') {
add_data_rom_path[add_data_rom_path_len - 1] = 0;
add_data_rom_path_len--;
}
if (add_data_rom_path.size() && add_data_rom_path.back() == '\\')
add_data_rom_path.pop_back();
std::vector<std::string> data_directories;
path_get_directories(&data_directories, add_data_rom_path, &main_rom_path, 1);
const char* exclude_list[1];
exclude_list[0] = main_rom_path.c_str();
std::vector<std::string> data_directories
= path_get_directories(add_data_rom_path.c_str(), exclude_list, 1);
max_len = 0;
for (std::string& k : data_directories) {
size_t len = k.size();
if (max_len < len)
max_len = len;
}
char* data_dir_path_temp = force_malloc_s(char, add_data_rom_path_len + max_len + add_data_rom_len + 3);
if (data_dir_path_temp) {
std::string data_dir_path;
if (data_directories.size()) {
j.data.reserve(data_directories.size() + 1);
memcpy(data_dir_path_temp, add_data_rom_path, add_data_rom_path_len);
data_dir_path_temp[add_data_rom_path_len] = '\\';
data_dir_path.assign(add_data_rom_path);
data_dir_path += '\\';
for (std::vector<std::string>::reverse_iterator k = data_directories.rbegin();
k != data_directories.rend(); k++) {
memcpy(&data_dir_path_temp[add_data_rom_path_len + 1], k->c_str(), k->size() + 1);
if (add_data_rom_len) {
data_dir_path_temp[add_data_rom_path_len + 1 + k->size()] = '\\';
memcpy(&data_dir_path_temp[add_data_rom_path_len + 1 + k->size() + 1],
add_data_rom, add_data_rom_len + 1);
}
data_struct_directory data_dir;
data_dir.path = data_dir_path_temp;
data_dir.name = *k;
data_dir.path.assign(data_dir_path);
data_dir.path.append(*k);
if (add_data_rom_len) {
data_dir.path += '\\';
data_dir.path.append(add_data_rom, add_data_rom_len);
}
data_dir.name.assign(*k);
j.data.push_back(data_dir);
}
}
else
j.data.reserve(1);
free(data_dir_path_temp);
data_struct_directory data_dir;
data_dir.path = main_rom_path;
data_dir.name = {};
j.data.push_back(data_dir);
free(data_dir_path_temp);
}
free(main_rom_path);
free(add_data_rom_path);
ds->ready = true;
}
free(buf);
free(lines);
free_def(buf);
free_def(lines);
}
#if defined(CRE_DEV)
static void data_load_glitter_list(data_struct* ds, const char* path) {
stream s;
file_stream s;
s.open(path, "rb");
size_t length = s.length;
uint8_t* data = force_malloc_s(uint8_t, length);
@@ -1145,7 +994,7 @@ static void data_load_glitter_list(data_struct* ds, const char* path) {
char* buf;
char** lines;
size_t count;
if (str_utils_text_file_parse(data, length, &buf, &lines, &count)) {
if (str_utils_text_file_parse(data, length, buf, lines, count)) {
for (size_t i = 0; i < count; i++) {
char* t = strstr(lines[i], "#(?)");
if (t)
@@ -1156,7 +1005,7 @@ static void data_load_glitter_list(data_struct* ds, const char* path) {
glitter_list_names.reserve(count);
for (size_t i = 0; i < count; i++) {
size_t len = utf8_length(lines[i]);
std::string name = std::string(lines[i], min(len, 0x7F));
std::string name = std::string(lines[i], min_def(len, 0x7F));
glitter_list_names.push_back(name);
}
@@ -1183,9 +1032,9 @@ static void data_load_glitter_list(data_struct* ds, const char* path) {
break;
}
free(buf);
free(lines);
free_def(buf);
free_def(lines);
}
free(data);
free_def(data);
}
#endif
src/CRE/data.hpp
+2
View File
@@ -12,6 +12,7 @@
#include "../KKdLib/database/bone.hpp"
#include "../KKdLib/database/motion.hpp"
#include "../KKdLib/database/object.hpp"
#include "../KKdLib/database/sprite.hpp"
#include "../KKdLib/database/stage.hpp"
#include "../KKdLib/database/texture.hpp"
#include "../KKdLib/vec.hpp"
@@ -68,6 +69,7 @@ struct data_ft {
bone_database bone_data;
motion_database mot_db;
object_database obj_db;
sprite_database spr_db;
stage_database stage_data;
texture_database tex_db;
src/CRE/draw_object.cpp
+46 -27
View File
@@ -66,8 +66,7 @@ void draw_object_draw(render_context* rctx, draw_object* draw, mat4* model,
if (!show_vector) {
gl_state_bind_vertex_array(rctx->object_data.get_vertex_array(
draw->array_buffer, draw->morph_array_buffer));
gl_state_bind_vertex_array(rctx->object_data.get_vertex_array(draw));
draw_object_func(rctx, draw);
}
uniform_value[U_BONE_MAT] = 0;
@@ -315,20 +314,17 @@ inline void model_mat_face_camera_position(mat4* view, mat4* src, mat4* dst) {
vec3 trans;
mat4_get_translation(view, &trans);
mat4_mult_vec3_inv_trans(view, &trans, &trans);
vec3_negate(trans, trans);
trans = -trans;
vec3 dir;
vec3_sub(trans, *(vec3*)&src->row3, dir);
vec3_normalize(dir, dir);
vec3 dir = vec3::normalize(trans - *(vec3*)&src->row3);
vec3 x_rot;
vec3 y_rot;
vec3 z_rot;
y_rot = *(vec3*)&src->row1;
vec3_cross(y_rot, dir, x_rot);
vec3_normalize(x_rot, x_rot);
vec3_cross(x_rot, y_rot, z_rot);
x_rot = vec3::normalize(vec3::cross(y_rot, dir));
z_rot = vec3::cross(x_rot, y_rot);
*(vec3*)&dst->row0 = x_rot;
*(vec3*)&dst->row1 = y_rot;
@@ -552,22 +548,23 @@ static void draw_object_material_set_default(render_context* rctx, draw_object*
else {
gl_state_active_bind_texture_2d(tex_index, tex_id);
GLenum wrap_s = 0;
GLenum wrap_s;
if (texdata->attrib.m.mirror_u)
wrap_s = GL_MIRRORED_REPEAT;
else if (texdata->attrib.m.repeat_u)
wrap_s = GL_REPEAT;
else
wrap_s = GL_CLAMP_TO_EDGE;
GLenum wrap_t = 0;
GLenum wrap_t;
if (texdata->attrib.m.mirror_v)
wrap_t = GL_MIRRORED_REPEAT;
else if (texdata->attrib.m.repeat_v)
wrap_t = GL_REPEAT;
else
wrap_t = GL_CLAMP_TO_EDGE;
if (wrap_s)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_s);
if (wrap_t)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_t);
texture_storage_set_texture_wrap(tex_id, wrap_s, wrap_t);
}
if (material->material.shader.index == SHADER_FT_SKY) {
@@ -615,9 +612,8 @@ static void draw_object_material_set_default(render_context* rctx, draw_object*
vec4 specular = material->material.color.specular;
shaders_ft.state_material_set_specular(false, specular);
float_t luma;
vec3 luma_coeff = { 0.30f, 0.59f, 0.11f };
vec3_dot(*(vec3*)&specular, luma_coeff, luma);
float_t luma = vec3::dot(*(vec3*)&specular, luma_coeff);
if (luma >= 0.0099999998f || draw->texture_color_coeff.w >= 0.1f)
uniform_value[U_SPECULAR_IBL] = 1;
else
@@ -654,7 +650,7 @@ static void draw_object_material_set_default(render_context* rctx, draw_object*
shininess = 10.0f;
else {
shininess = (material->material.color.shininess - 16.0f) * (float_t)(1.0 / 112.0);
shininess = max(shininess, 0.0f);
shininess = max_def(shininess, 0.0f);
}
shaders_ft.state_material_set_shininess(false, shininess, 0.0f, 0.0f, 1.0f);
@@ -668,7 +664,7 @@ static void draw_object_material_set_default(render_context* rctx, draw_object*
shaders_ft.local_vert_set(0, fresnel, 0.18f, line_light, 0.0f);
shaders_ft.local_frag_set(9, fresnel, 0.18f, line_light, 0.0f);
shininess = max(material->material.color.shininess, 1.0f);
shininess = max_def(material->material.color.shininess, 1.0f);
shaders_ft.local_vert_set(1, shininess, 0.0f, 0.0f, 0.0f);
shaders_ft.local_frag_set(3, shininess, 0.0f, 0.0f, 0.0f);
@@ -724,7 +720,7 @@ static void draw_object_material_set_parameter(render_context* rctx, obj_materia
inv_bump_depth = (1.0f - bump_depth) * 256.0f + 1.0f;
}
intensity = max(intensity, 1.0f);
intensity = max_def(intensity, 1.0f);
shaders_ft.local_vert_set(2, inv_bump_depth, bump_depth, 0.0f, 0.0f);
shaders_ft.local_frag_set(0, inv_bump_depth, bump_depth, 0.0f, 0.0f);
@@ -735,7 +731,7 @@ static void draw_object_material_set_parameter(render_context* rctx, obj_materia
vec4 specular;
shaders_ft.env_vert_get(17, specular);
vec3_mult(*(vec3*)&specular, *(vec3*)&mat_data->material.color.specular, *(vec3*)&specular);
*(vec3*)&specular = *(vec3*)&specular * *(vec3*)&mat_data->material.color.specular;
shaders_ft.env_vert_set(18, specular);
}
@@ -768,22 +764,23 @@ static void draw_object_material_set_reflect(render_context* rctx, draw_object*
gl_state_active_bind_texture_2d(i, tex_id);
GLenum wrap_s = 0;
GLenum wrap_s;
if (texdata->attrib.m.mirror_u)
wrap_s = GL_MIRRORED_REPEAT;
else if (texdata->attrib.m.repeat_u)
wrap_s = GL_REPEAT;
else
wrap_s = GL_CLAMP_TO_EDGE;
GLenum wrap_t = 0;
GLenum wrap_t;
if (texdata->attrib.m.mirror_v)
wrap_t = GL_MIRRORED_REPEAT;
else if (texdata->attrib.m.repeat_v)
wrap_t = GL_REPEAT;
else
wrap_t = GL_CLAMP_TO_EDGE;
if (wrap_s)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_s);
if (wrap_t)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_t);
texture_storage_set_texture_wrap(tex_id, wrap_s, wrap_t);
}
vec4 ambient;
@@ -940,18 +937,30 @@ static void draw_object_vertex_attrib_set_default(draw_object* draw) {
if (vertex_format & OBJ_VERTEX_BONE_DATA)
uniform_value[U_BONE_MAT] = 1;
else
uniform_value[U_BONE_MAT] = 0;
if (draw->morph_array_buffer) {
uniform_value[U_MORPH] = 1;
if (vertex_format & OBJ_VERTEX_COLOR0)
uniform_value[U_MORPH_COLOR] = 1;
else
uniform_value[U_MORPH_COLOR] = 0;
shaders_ft.env_vert_set(13, draw->morph_value, 1.0f - draw->morph_value, 0.0f, 0.0f);
}
else {
uniform_value[U_MORPH] = 0;
uniform_value[U_MORPH_COLOR] = 0;
shaders_ft.env_vert_set(13, 0.0f, 1.0f, 0.0f, 0.0f);
}
if (draw->instances_count)
uniform_value[U_INSTANCE] = 1;
else
uniform_value[U_INSTANCE] = 0;
}
static void draw_object_vertex_attrib_set_reflect(draw_object* draw) {
@@ -977,13 +986,23 @@ static void draw_object_vertex_attrib_set_reflect(draw_object* draw) {
if (vertex_format & OBJ_VERTEX_BONE_DATA)
uniform_value[U_BONE_MAT] = 1;
else
uniform_value[U_BONE_MAT] = 0;
if (draw->morph_array_buffer) {
uniform_value[U_MORPH] = 1;
if (vertex_format & OBJ_VERTEX_COLOR0)
uniform_value[U_MORPH_COLOR] = 1;
else
uniform_value[U_MORPH_COLOR] = 0;
shaders_ft.env_vert_set(13, draw->morph_value, 1.0f - draw->morph_value, 0.0f, 0.0f);
}
else {
uniform_value[U_MORPH] = 0;
uniform_value[U_MORPH_COLOR] = 0;
shaders_ft.env_vert_set(13, 0.0f, 1.0f, 0.0f, 0.0f);
}
}
src/CRE/draw_pass.cpp
+21 -18
View File
@@ -109,10 +109,16 @@ void draw_pass_main(render_context* rctx) {
break;
case DRAW_PASS_CLEAR: {
rctx->post_process.rend_texture.bind();
vec4 _clear_color;
vec4u8_to_vec4(clear_color, _clear_color);
vec4_mult_scalar(_clear_color, (float_t)(1.0 / 255.0), _clear_color);
glClearBufferfv(GL_COLOR, 0, (GLfloat*)&_clear_color);
if (set_clear_color) {
vec4 _clear_color;
vec4u8_to_vec4(clear_color, _clear_color);
_clear_color *= (float_t)(1.0 / 255.0);
glClearBufferfv(GL_COLOR, 0, (GLfloat*)&_clear_color);
}
else {
vec4 _clear_color = {};
glClearBufferfv(GL_COLOR, 0, (GLfloat*)&_clear_color);
}
//sub_140501470(rctx, &rctx->draw_pass);
} break;
case DRAW_PASS_PRE_SPRITE:
@@ -523,11 +529,8 @@ static void draw_pass_sss_contour(render_context* rctx, post_process* pp) {
camera* cam = rctx->camera;
float_t v3 = 1.0f / tanf((float_t)(cam->fov_rad * 0.5));
vec3 direction;
vec3_sub(cam->interest, cam->view_point, direction);
vec3_normalize(direction, direction);
float_t length;
vec3_length(direction, length);
vec3 direction = cam->interest - cam->view_point;
float_t length = vec3::length(direction);
float_t v7 = direction.y;
if (length != 0.0)
v7 /= length;
@@ -607,7 +610,7 @@ static void draw_pass_sss_filter(render_context* rctx, sss_data* a1) {
mat4* mat = rob_chara_bone_data_get_mats_mat(v16, MOTION_BONE_N_HARA_CP);
if (mat) {
mat4_get_translation(mat, &chara_position[i]);
vec3_distance(view_point, chara_position[i], chara_distance[i]);
chara_distance[i] = vec3::distance(view_point, chara_position[i]);
}
}
}
@@ -620,13 +623,11 @@ static void draw_pass_sss_filter(render_context* rctx, sss_data* a1) {
else
closest_chara_position = chara_position[0];
float_t length;
vec3_distance(interest, closest_chara_position, length);
float_t length = vec3::distance(interest, closest_chara_position);
if (length > 1.25f)
interest = chara_position[0];
float_t v29;
vec3_distance(view_point, interest, v29);
float_t v29 = vec3::distance(view_point, interest);
if (v29 < 0.25f)
v29 = 0.25f;
float_t v31 = tanf((float_t)(rctx->camera->fov_rad * 0.5)) * 5.0f;
@@ -634,7 +635,7 @@ static void draw_pass_sss_filter(render_context* rctx, sss_data* a1) {
v31 = 0.25f;
float_t v32 = v31 * v29;
float_t v33 = 0.6f;
float_t v34 = 1.0f / clamp(v32, 0.25f, 100.0f);
float_t v34 = 1.0f / clamp_def(v32, 0.25f, 100.0f);
if (v34 < 0.145) {
float_t v36 = v34 - 0.02f;
if (v34 < 0.0f)
@@ -718,11 +719,13 @@ static void draw_pass_reflect(render_context* rctx, draw_pass* a1) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
rctx->draw_state.shader_index = SHADER_FT_S_REFL;
bool clip_plane[4];
light_set* set = &rctx->light_set[LIGHT_SET_MAIN];
light_clip_plane clip_plane;
set->lights[LIGHT_SPOT].get_clip_plane(clip_plane);
uniform_value[U_REFLECT] = 2;
uniform_value[U_CLIP_PLANE] = clip_plane[1];
uniform_value[U_CLIP_PLANE] = clip_plane.data[1];
gl_state_enable_depth_test();
gl_state_set_depth_func(GL_LEQUAL);
gl_state_set_depth_mask(GL_TRUE);
@@ -737,7 +740,7 @@ static void draw_pass_reflect(render_context* rctx, draw_pass* a1) {
if (a1->reflect_type == STAGE_DATA_REFLECT_REFLECT_MAP) {
uniform_value[U_REFLECT] = a1->field_31E;
uniform_value[U_CLIP_PLANE] = clip_plane[0];
uniform_value[U_CLIP_PLANE] = clip_plane.data[0];
draw_task_draw_objects_by_type(rctx, DRAW_OBJECT_REFLECT_CHARA_OPAQUE, 0, 0, 1, -1);
}
gl_state_disable_depth_test();
src/CRE/draw_task.cpp
+33 -57
View File
@@ -170,7 +170,7 @@ void draw_task_draw_objects_by_type(render_context* rctx, draw_object_type type,
switch (task->type) {
case DRAW_TASK_OBJECT: {
int32_t a = (int32_t)(task->data.object.blend_color.w * 255.0f);
a = clamp(a, 0, 255);
a = clamp_def(a, 0, 255);
if (a == alpha) {
draw_object_draw(rctx, &task->data.object,
&task->mat, draw_object_func, show_vector);
@@ -180,7 +180,7 @@ void draw_task_draw_objects_by_type(render_context* rctx, draw_object_type type,
for (int32_t j = 0; j < task->data.object_translucent.count; j++) {
draw_object* object = task->data.object_translucent.objects[j];
int32_t a = (int32_t)(object->blend_color.w * 255.0f);
a = clamp(a, 0, 255);
a = clamp_def(a, 0, 255);
if (a == alpha)
draw_object_draw(rctx, object,
&task->mat, draw_object_func, show_vector);
@@ -228,15 +228,16 @@ void draw_task_draw_objects_by_type_translucent(render_context* rctx, bool opaqu
&& draw_task_get_count(rctx, translucent) < 1)
return;
post_process* pp = &rctx->post_process;
int32_t alpha_array[256];
int32_t count = draw_task_translucent_sort_count_layers(rctx,
alpha_array, opaque, transparent, translucent);
for (int32_t i = 0; i < count; i++) {
int32_t alpha = alpha_array[i];
fbo::blit(rctx->post_process.rend_texture.fbos[0],
rctx->post_process.alpha_layer_texture.fbos[0],
0, 0, rctx->post_process.render_width, rctx->post_process.render_height,
0, 0, rctx->post_process.render_width, rctx->post_process.render_height,
fbo::blit(pp->rend_texture.fbos[0], pp->alpha_layer_texture.fbos[0],
0, 0, pp->render_width, pp->render_height,
0, 0, pp->render_width, pp->render_height,
GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, GL_NEAREST);
if (opaque_enable && draw_task_get_count(rctx, opaque))
@@ -249,17 +250,16 @@ void draw_task_draw_objects_by_type_translucent(render_context* rctx, bool opaqu
gl_state_disable_blend();
}
rctx->post_process.buf_texture.bind();
render_texture::shader_set_glsl(&rctx->post_process.alpha_layer_shader);
gl_state_active_bind_texture_2d(0, rctx->post_process.alpha_layer_texture.color_texture->tex);
gl_state_active_bind_texture_2d(1, rctx->post_process.rend_texture.color_texture->tex);
pp->buf_texture.bind();
render_texture::shader_set_glsl(&pp->alpha_layer_shader);
gl_state_active_bind_texture_2d(0, pp->alpha_layer_texture.color_texture->tex);
gl_state_active_bind_texture_2d(1, pp->rend_texture.color_texture->tex);
glUniform1f(0, (float_t)(alpha * (1.0 / 255.0)));
render_texture::draw_custom_glsl();
fbo::blit(rctx->post_process.buf_texture.fbos[0],
rctx->post_process.rend_texture.fbos[0],
0, 0, rctx->post_process.render_width, rctx->post_process.render_height,
0, 0, rctx->post_process.render_width, rctx->post_process.render_height,
fbo::blit(pp->buf_texture.fbos[0], pp->rend_texture.fbos[0],
0, 0, pp->render_width, pp->render_height,
0, 0, pp->render_width, pp->render_height,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
}
}
@@ -430,7 +430,7 @@ bool draw_task_add_draw_object(render_context* rctx, obj* object,
if (!has_blend_color)
_blend_color = *blend_color;
else
vec4_mult(_blend_color, *blend_color, _blend_color);
_blend_color *= *blend_color;
}
bool has_emission = false;
@@ -711,7 +711,7 @@ void draw_task_add_draw_object_by_object_info_object_skin(render_context* rctx,
if (texture_data && !texture_data->field_0) {
vec4 value;
object_data->get_texture_color_coeff(texture_color_coeff);
vec3_mult(texture_data->texture_color_coeff, *(vec3*)&texture_color_coeff, *(vec3*)&value);
*(vec3*)&value = texture_data->texture_color_coeff * *(vec3*)&texture_color_coeff;
value.w = 0.0f;
object_data->set_texture_color_coeff(value);
@@ -721,7 +721,7 @@ void draw_task_add_draw_object_by_object_info_object_skin(render_context* rctx,
object_data->set_texture_color_offset(value);
object_data->get_texture_specular_coeff(texture_specular_coeff);
vec3_mult(texture_data->texture_specular_coeff, *(vec3*)&texture_specular_coeff, *(vec3*)&value);
*(vec3*)&value = texture_data->texture_specular_coeff * *(vec3*)&texture_specular_coeff;
value.w = 0.0f;
object_data->set_texture_specular_coeff(value);
@@ -778,9 +778,9 @@ void draw_task_sort(render_context* rctx, draw_object_type type, int32_t compare
for (uint32_t j = 0; j < sub_mesh->bone_indices_count; j++) {
center = sub_mesh->bounding_sphere.center;
mat4_mult_vec3_trans(&task->data.object.mats[j], &center, &center);
vec3_add(center_sum, center, center_sum);
center_sum += center;
}
vec3_mult_scalar(center_sum, 1.0f / (float_t)sub_mesh->bone_indices_count, center);
center_sum *= 1.0f / (float_t)sub_mesh->bone_indices_count;
}
task->bounding_radius = task->data.object.mesh->bounding_sphere.radius;
}
@@ -807,33 +807,15 @@ void draw_task_sort(render_context* rctx, draw_object_type type, int32_t compare
int32_t obj_axis_aligned_bounding_box_check_visibility(
obj_axis_aligned_bounding_box* aabb, camera* cam, mat4* mat) {
vec3 size;
vec3 points[8];
vec3 neg;
neg = { 0.0f, 0.0f, 0.0f };
vec3_xor(aabb->size, neg, size);
vec3_add(aabb->center, size, points[0]);
neg = { -0.0f, -0.0f, -0.0f };
vec3_xor(aabb->size, neg, size);
vec3_add(aabb->center, size, points[1]);
neg = { -0.0f, 0.0f, 0.0f };
vec3_xor(aabb->size, neg, size);
vec3_add(aabb->center, size, points[2]);
neg = { 0.0f, -0.0f, -0.0f };
vec3_xor(aabb->size, neg, size);
vec3_add(aabb->center, size, points[3]);
neg = { 0.0f, -0.0f, 0.0f };
vec3_xor(aabb->size, neg, size);
vec3_add(aabb->center, size, points[4]);
neg = { -0.0f, 0.0f, -0.0f };
vec3_xor(aabb->size, neg, size);
vec3_add(aabb->center, size, points[5]);
neg = { 0.0f, 0.0f, -0.0f };
vec3_xor(aabb->size, neg, size);
vec3_add(aabb->center, size, points[6]);
neg = { -0.0f, -0.0f, 0.0f };
vec3_xor(aabb->size, neg, size);
vec3_add(aabb->center, size, points[7]);
points[0] = aabb->center + (aabb->size ^ vec3( 0.0f, 0.0f, 0.0f));
points[1] = aabb->center + (aabb->size ^ vec3(-0.0f, -0.0f, -0.0f));
points[2] = aabb->center + (aabb->size ^ vec3(-0.0f, 0.0f, 0.0f));
points[3] = aabb->center + (aabb->size ^ vec3( 0.0f, -0.0f, -0.0f));
points[4] = aabb->center + (aabb->size ^ vec3( 0.0f, -0.0f, 0.0f));
points[5] = aabb->center + (aabb->size ^ vec3(-0.0f, 0.0f, -0.0f));
points[6] = aabb->center + (aabb->size ^ vec3( 0.0f, 0.0f, -0.0f));
points[7] = aabb->center + (aabb->size ^ vec3(-0.0f, -0.0f, 0.0f));
mat4 view_mat;
mat4_mult(mat, &cam->view, &view_mat);
@@ -856,9 +838,7 @@ int32_t obj_axis_aligned_bounding_box_check_visibility(
for (int32_t i = 0; i < 6; i++)
for (int32_t j = 0; j < 8; j++) {
float_t v34 = 0.0f;
vec3_dot(*(vec3*)&v2[i], points[j], v34);
v34 += v2[i].w;
float_t v34 = vec3::dot(*(vec3*)&v2[i], points[j]) + v2[i].w;
if (v34 > 0.0f)
break;
@@ -883,23 +863,19 @@ int32_t object_bounding_sphere_check_visibility(obj_bounding_sphere* sphere,
if (-cam->min_distance < min_depth || -cam->max_distance > max_depth)
return 0;
float_t v5;
vec3_dot(cam->field_1E4, center, v5);
float_t v5 = vec3::dot(cam->field_1E4, center);
if (v5 < -radius)
return 0;
float_t v6;
vec3_dot(cam->field_1F0, center, v6);
float_t v6 = vec3::dot(cam->field_1F0, center);
if (v6 < -radius)
return 0;
float_t v7;
vec3_dot(cam->field_1FC, center, v7);
float_t v7 = vec3::dot(cam->field_1FC, center);
if (v7 < -radius)
return 0;
float_t v8;
vec3_dot(cam->field_208, center, v8);
float_t v8 = vec3::dot(cam->field_208, center);
if (v8 < -radius)
return 0;
@@ -1018,7 +994,7 @@ inline static void draw_task_translucent_sort_has_objects(render_context* rctx,
continue;
int32_t alpha = (int32_t)(task->data.object.blend_color.w * 255.0f);
alpha = clamp(alpha, 0, 255);
alpha = clamp_def(alpha, 0, 255);
arr[alpha] = true;
}
}
src/CRE/fbo.cpp
+1 -1
View File
@@ -26,7 +26,7 @@ void fbo::init_data(int32_t width, int32_t height,
textures = 0;
}
count = min(count, 8);
count = min_def(count, 8);
this->width = width;
this->height = height;
src/CRE/file_handler.cpp
+90 -70
View File
@@ -4,6 +4,7 @@
*/
#include <thread>
#include "../KKdLib/io/file_stream.hpp"
#include "../KKdLib/hash.hpp"
#include "file_handler.hpp"
#include "data.hpp"
@@ -56,42 +57,50 @@ reading(), cache(), callback(), size(), data(), ds() {
}
file_handler::~file_handler() {
free(data);
if (data) {
free(data);
data = 0;
}
}
void file_handler::call_callback(int32_t index) {
if (index >= 2)
return;
std::unique_lock<std::mutex> u_lock(mtx);
const void* data = this->data;
void(*callback_func)(void*, const void*, size_t) = this->callback[index].func;
void* callback_data = this->callback[index].data;
bool ready = this->callback[index].ready;
this->callback[index].ready = true;
u_lock.unlock();
const void* data = 0;
size_t size = 0;
void(*callback_func)(void*, const void*, size_t) = 0;
void* callback_data = 0;
bool ready = false;
{
std::unique_lock<std::mutex> u_lock(mtx);
data = this->data;
size = this->size;
callback_func = this->callback[index].func;
callback_data = this->callback[index].data;
ready = this->callback[index].ready;
this->callback[index].ready = true;
}
if (!ready && callback_func)
callback_func(callback_data, data, this->size);
callback_func(callback_data, data, size);
}
void file_handler::set_file(const char* file) {
std::unique_lock<std::mutex> u_lock(mtx);
this->file = file;
u_lock.unlock();
this->file.assign(file);
}
void file_handler::set_farc_file(const char* farc_file, bool cache) {
std::unique_lock<std::mutex> u_lock(mtx);
this->farc_file = farc_file;
this->farc_file.assign(farc_file);
this->cache = cache;
u_lock.unlock();
}
void file_handler::set_dir(const char* dir) {
std::unique_lock<std::mutex> u_lock(mtx);
this->dir = dir;
u_lock.unlock();
this->dir.assign(dir);
}
void file_handler::set_callback_data(int32_t index, PFNFILEHANDLERCALLBACK* func, void* data) {
@@ -101,20 +110,21 @@ void file_handler::set_callback_data(int32_t index, PFNFILEHANDLERCALLBACK* func
callback[index].data = data;
callback[index].ready = false;
}
u_lock.unlock();
}
void file_handler::free_data_lock() {
std::unique_lock<std::mutex> u_lock(mtx);
if (count > 0) {
count--;
bool free_fhndl = count == 0;
u_lock.unlock();
if (free_fhndl)
delete this;
bool free_fhndl = false;
{
std::unique_lock<std::mutex> u_lock(mtx);
if (count <= 0)
return;
free_fhndl = --count == 0;
}
else
u_lock.unlock();
if (free_fhndl)
delete this;
}
farc_read_handler::farc_read_handler() : cache(), farc() {
@@ -159,8 +169,8 @@ bool farc_read_handler::read_data(void* data, size_t size, std::string& file) {
if (farc) {
farc_file* ff = farc->read_file(file.c_str());
if (ff) {
memcpy(data, ff->data, min(size, ff->size));
if (!cache) {
memcpy(data, ff->data, min_def(size, ff->size));
if (!cache && ff->data) {
free(ff->data);
ff->data = 0;
}
@@ -191,27 +201,30 @@ void file_handler_storage_init() {
void file_handler_storage_ctrl() {
file_handler_storage_ctrl_list();
std::unique_lock<std::mutex> u_lock(file_handler_storage_data->mtx);
if (!file_handler_storage_data->deque.size()) {
for (file_handler*& i : file_handler_storage_data->list)
if (i->not_ready && !i->reading) {
std::unique_lock<std::mutex> u_lock(i->mtx);
i->count++;
u_lock.unlock();
file_handler_storage_data->deque.push_back(i);
}
{
std::unique_lock<std::mutex> u_lock(file_handler_storage_data->mtx);
if (!file_handler_storage_data->deque.size()) {
for (file_handler*& i : file_handler_storage_data->list)
if (i->not_ready && !i->reading) {
{
std::unique_lock<std::mutex> u_lock(i->mtx);
i->count++;
}
file_handler_storage_data->deque.push_back(i);
}
if (file_handler_storage_data->deque.size())
file_handler_storage_data->cnd.notify_all();
if (file_handler_storage_data->deque.size())
file_handler_storage_data->cnd.notify_all();
}
}
u_lock.unlock();
}
void file_handler_storage_free() {
std::unique_lock<std::mutex> u_lock(file_handler_storage_data->mtx);
file_handler_storage_data->exit = true;
file_handler_storage_data->cnd.notify_one();
u_lock.unlock();
{
std::unique_lock<std::mutex> u_lock(file_handler_storage_data->mtx);
file_handler_storage_data->exit = true;
file_handler_storage_data->cnd.notify_one();
}
file_handler_storage_data->thread->join();
delete file_handler_storage_data->thread;
@@ -233,11 +246,13 @@ static bool file_handler_load_file(void* data, const char* dir, const char* file
if (!fhndl->data)
return false;
stream s;
file_stream s;
s.open(file_path.c_str(), "rb");
bool ret = s.io.stream && s.read(fhndl->data, fhndl->size);
if (!ret)
bool ret = s.check_not_null() && s.read(fhndl->data, fhndl->size);
if (!ret && fhndl->data) {
free(fhndl->data);
fhndl->data = 0;
}
return ret;
}
@@ -266,14 +281,14 @@ static bool file_handler_load_farc_file(void* data, const char* dir, const char*
fhndl->size = 1;
fhndl->data = malloc(fhndl->size);
if (fhndl->data && farc_read_hndl->read_data(fhndl->data, fhndl->size, fhndl->file)) {
u_lock.unlock();
if (fhndl->data && farc_read_hndl->read_data(fhndl->data, fhndl->size, fhndl->file))
return true;
}
}
free(fhndl->data);
u_lock.unlock();
if (fhndl->data) {
free(fhndl->data);
fhndl->data = 0;
}
return false;
}
@@ -313,14 +328,12 @@ static void file_handler_storage_thread_ctrl() {
i->dir.c_str(), i->file.c_str(), file_handler_load_file);
}
i->reading = false;
u_lock.unlock();
}
i->free_data_lock();
}
file_handler_storage_data->deque.clear();
}
file_handler_storage_data->exit = false;
u_lock.unlock();
}
p_file_handler::p_file_handler() {
@@ -355,10 +368,12 @@ void p_file_handler::free_data() {
if (!ptr)
return;
std::unique_lock<std::mutex> u_lock(ptr->mtx);
for (int32_t i = 0; i < 2; i++)
ptr->callback[i] = {};
u_lock.unlock();
{
std::unique_lock<std::mutex> u_lock(ptr->mtx);
for (int32_t i = 0; i < 2; i++)
ptr->callback[i] = {};
}
ptr->free_data_lock();
ptr = 0;
}
@@ -410,18 +425,21 @@ bool p_file_handler::read_file(void* data, const char* dir,
ptr->ds = data;
std::unique_lock<std::mutex> u_lock(ptr->mtx);
ptr->count++;
u_lock.unlock();
{
std::unique_lock<std::mutex> u_lock(ptr->mtx);
ptr->count++;
}
ptr->set_dir(dir);
if (farc_file)
ptr->set_farc_file(farc_file, cache);
ptr->set_file(file);
std::unique_lock<std::mutex> u_lock1(ptr->mtx);
ptr->count++;
u_lock1.unlock();
{
std::unique_lock<std::mutex> u_lock(ptr->mtx);
ptr->count++;
}
file_handler_storage_data->list.push_back(ptr);
return true;
}
@@ -450,16 +468,19 @@ bool p_file_handler::read_file(void* data, const char* dir, uint32_t hash, const
ptr->ds = data;
std::unique_lock<std::mutex> u_lock(ptr->mtx);
ptr->count++;
u_lock.unlock();
{
std::unique_lock<std::mutex> u_lock(ptr->mtx);
ptr->count++;
}
ptr->set_dir(dir);
ptr->set_file(file.c_str());
std::unique_lock<std::mutex> u_lock1(ptr->mtx);
ptr->count++;
u_lock1.unlock();
{
std::unique_lock<std::mutex> u_lock(ptr->mtx);
ptr->count++;
}
file_handler_storage_data->list.push_back(ptr);
return true;
}
@@ -485,7 +506,6 @@ void p_file_handler::read_now() {
ptr->not_ready = false;
}
ptr->reading = false;
u_lock.unlock();
}
file_handler_storage_ctrl_list();
src/CRE/item_table.cpp
+17 -3
View File
@@ -3,6 +3,7 @@
GitHub/GitLab: korenkonder
*/
#include "../KKdLib/io/memory_stream.hpp"
#include "../KKdLib/io/path.hpp"
#include "../KKdLib/str_utils.hpp"
#include "data.hpp"
@@ -72,6 +73,19 @@ item_table_item_data_obj::item_table_item_data_obj() : rpk() {
}
item_table_item_data_ofs::item_table_item_data_ofs() : sub_id(), no() {
}
item_table_item_data_tex::item_table_item_data_tex() {
org = -1;
chg = -1;
}
item_table_item_data_col::item_table_item_data_col() : flag() {
tex_id = -1;
}
item_table_item_data::item_table_item_data() {
}
@@ -111,7 +125,7 @@ static bool item_table_array_read(data_struct* data, const char* path) {
char* path_farc = str_utils_add(path, ".farc");
if (!path_check_file_exists(path_farc)) {
free(path_farc);
free_def(path_farc);
return false;
}
@@ -155,7 +169,7 @@ static bool item_table_array_read(data_struct* data, const char* path) {
farc_file* ff = f.read_file(file);
if (ff) {
stream s;
memory_stream s;
s.open(ff->data, ff->size);
itm_table itm;
itm.read(ff->data, ff->size);
@@ -163,7 +177,7 @@ static bool item_table_array_read(data_struct* data, const char* path) {
item_table_load(data, &item_table_array[i], &itm);
}
}
free(path_farc);
free_def(path_farc);
return true;
}
src/CRE/item_table.hpp
+6
View File
@@ -24,17 +24,23 @@ struct item_table_item_data_ofs {
vec3 position;
vec3 rotation;
vec3 scale;
item_table_item_data_ofs();
};
struct item_table_item_data_tex {
uint32_t org;
uint32_t chg;
item_table_item_data_tex();
};
struct item_table_item_data_col {
uint32_t tex_id;
int32_t flag;
color_tone col_tone;
item_table_item_data_col();
};
struct item_table_item_data {
src/CRE/light_param.cpp
+16 -8
View File
@@ -70,6 +70,14 @@ void light_param_data_storage_data_init() {
light_param_data_storage_data = new light_param_data_storage;
}
int32_t light_param_data_storage_data_get_pv_id() {
return light_param_data_storage_data->pv_id;
}
int32_t light_param_data_storage_data_get_stage_index() {
return light_param_data_storage_data->stage_index;
}
void light_param_data_storage_data_free_file_handlers() {
light_param_storage_free_file_handlers(light_param_data_storage_data);
}
@@ -226,7 +234,7 @@ static void light_param_data_get_stage_name_string(std::string* str, int32_t sta
s[length] = '\0';
*str = std::string(s, length);
free(s);
free_def(s);
}
static void light_param_data_get_stage_name_string(std::string* str,
@@ -267,7 +275,7 @@ static void light_param_data_get_stage_name_string(std::string* str,
s[length] = '\0';
*str = std::string(s, length);
free(s);
free_def(s);
}
static int32_t light_param_data_load_file(light_param_data* a1, p_file_handler* a2) {
@@ -318,27 +326,27 @@ static void light_param_data_load_file_pv_cut(std::map<int32_t, light_param_data
size_t name_len = i.name.size();
int32_t type = 0;
if (!strncmp(name, "light", min(name_len, 5)) && name_len > 6 && name[5] == '_') {
if (!strncmp(name, "light", min_def(name_len, 5)) && name_len > 6 && name[5] == '_') {
type = 1;
name += 6;
name_len -= 6;
}
else if (!strncmp(name, "fog", min(name_len, 3)) && name_len > 4 && name[3] == '_') {
else if (!strncmp(name, "fog", min_def(name_len, 3)) && name_len > 4 && name[3] == '_') {
type = 2;
name += 4;
name_len -= 4;
}
else if (!strncmp(name, "glow", min(name_len, 4)) && name_len > 5 && name[4] == '_') {
else if (!strncmp(name, "glow", min_def(name_len, 4)) && name_len > 5 && name[4] == '_') {
type = 3;
name += 5;
name_len -= 5;
}
else if (!strncmp(name, "wind", min(name_len, 4)) && name_len > 5 && name[4] == '_') {
else if (!strncmp(name, "wind", min_def(name_len, 4)) && name_len > 5 && name[4] == '_') {
type = 4;
name += 5;
name_len -= 5;
}
else if (!strncmp(name, "face", min(name_len, 4)) && name_len > 5 && name[4] == '_') {
else if (!strncmp(name, "face", min_def(name_len, 4)) && name_len > 5 && name[4] == '_') {
type = 5;
name += 5;
name_len -= 5;
@@ -576,7 +584,7 @@ static void light_param_storage_load_stages(light_param_data_storage* a1,
continue;
size_t name_len = name.size();
if (!strncmp(name.c_str(), "pv0", min(name_len, 3)))
if (!strncmp(name.c_str(), "pv0", min_def(name_len, 3)))
name[2] = '8';
std::map<int32_t, light_param_data>::iterator elem = a1->stage.find(i);
src/CRE/light_param.hpp
+2
View File
@@ -69,6 +69,8 @@ struct light_param_data_storage {
extern void light_param_data_storage_data_init();
extern void light_param_data_storage_data_free_file_handlers();
extern int32_t light_param_data_storage_data_get_pv_id();
extern int32_t light_param_data_storage_data_get_stage_index();
extern int32_t light_param_data_storage_data_load_file();
extern void light_param_data_storage_data_load_stage(int32_t stage_index);
extern void light_param_data_storage_data_load_stage(uint32_t stage_hash, stage_database* stage_data);
src/CRE/light_param/fog.cpp
+1 -2
View File
@@ -91,8 +91,7 @@ void fog::data_set(fog_id id) {
shaders_ft.env_vert_set(29, color);
shaders_ft.env_frag_set(4, color);
vec4_mult_scalar(color, (float_t)(1.0 / 8.0), color);
shaders_ft.state_fog_set_color(color);
shaders_ft.state_fog_set_color(color * (float_t)(1.0 / 8.0));
shaders_ft.state_fog_set_params(params);
} break;
case FOG_HEIGHT: {
src/CRE/light_param/light.cpp
+55 -72
View File
@@ -13,8 +13,8 @@ extern vec4 npr_spec_color;
static void light_get_direction_from_position(vec4* pos_dir, light_data* light, bool force);
light_data::light_data() : type(), ambient(), diffuse(), specular(), position(),
spot_direction(), spot_exponent(), spot_cutoff(), constant(), linear(), quadratic(),
ibl_specular(), ibl_back(), ibl_direction(), tone_curve(),clip_plane() {
spot_direction(), spot_exponent(), spot_cutoff(), attenuation(),
ibl_specular(), ibl_back(), ibl_direction(), tone_curve(), clip_plane() {
set_type(LIGHT_OFF);
set_ambient({ 0.0f, 0.0, 0.0f, 1.0f });
set_diffuse({ 1.0f, 1.0, 1.0f, 0.0f });
@@ -207,45 +207,39 @@ void light_data::set_spot_cutoff(float_t value) {
}
float_t light_data::get_constant() {
return constant;
return attenuation.constant;
}
void light_data::set_constant(float_t value) {
constant = value;
attenuation.constant = value;
}
float_t light_data::get_linear() {
return linear;
return attenuation.linear;
}
void light_data::set_linear(float_t value) {
linear = value;
attenuation.linear = value;
}
float_t light_data::get_quadratic() {
return quadratic;
return attenuation.quadratic;
}
void light_data::set_quadratic(float_t value) {
quadratic = value;
attenuation.quadratic = value;
}
void light_data::get_attenuation(vec3& value) {
value.x = constant;
value.y = linear;
value.z = quadratic;
void light_data::get_attenuation(light_attenuation& value) {
value = attenuation;
}
void light_data::set_attenuation(const vec3& value) {
constant = value.x;
linear = value.y;
quadratic = value.z;
void light_data::set_attenuation(const light_attenuation& value) {
attenuation = value;
}
void light_data::set_attenuation(const vec3&& value) {
constant = value.x;
linear = value.y;
quadratic = value.z;
void light_data::set_attenuation(const light_attenuation&& value) {
attenuation = value;
}
void light_data::get_ibl_specular(vec4& value) {
@@ -284,30 +278,28 @@ void light_data::set_ibl_direction(const vec4&& value) {
ibl_direction = value;
}
void light_data::get_tone_curve(vec3& value) {
void light_data::get_tone_curve(light_tone_curve& value) {
value = tone_curve;
}
void light_data::set_tone_curve(const vec3& value) {
void light_data::set_tone_curve(const light_tone_curve& value) {
tone_curve = value;
}
void light_data::set_tone_curve(const vec3&& value) {
void light_data::set_tone_curve(const light_tone_curve&& value) {
tone_curve = value;
}
void light_data::get_clip_plane(bool value[4]) {
value[0] = clip_plane[0];
value[1] = clip_plane[1];
value[2] = clip_plane[2];
value[3] = clip_plane[3];
void light_data::get_clip_plane(light_clip_plane& value) {
value = clip_plane;
}
void light_data::set_clip_plane(const bool value[4]) {
clip_plane[0] = value[0];
clip_plane[1] = value[1];
clip_plane[2] = value[2];
clip_plane[3] = value[3];
void light_data::set_clip_plane(const light_clip_plane& value) {
clip_plane = value;
}
void light_data::set_clip_plane(const light_clip_plane&& value) {
clip_plane = value;
}
void light_set::get_ambient_intensity(vec4& value) {
@@ -364,8 +356,9 @@ void light_set::data_set(face& face, light_set_id id) {
light_get_direction_from_position(&light_position, 0, true);
shaders_ft.state_light_set_position(i, light_position);
light_attenuation attenuation = light->attenuation;
shaders_ft.state_light_set_attenuation(i,
light->constant, light->linear, light->quadratic, light->spot_exponent);
attenuation.constant, attenuation.linear, attenuation.quadratic, light->spot_exponent);
vec3 spot_direction = light->spot_direction;
shaders_ft.state_light_set_spot_direction(i,
@@ -393,21 +386,19 @@ void light_set::data_set(face& face, light_set_id id) {
shaders_ft.env_vert_set(5, position);
shaders_ft.env_frag_set(5, position);
vec4_mult(diffuse, ibl_specular, temp);
temp = diffuse * ibl_specular;
shaders_ft.env_vert_set(6, temp);
shaders_ft.env_frag_set(6, temp);
vec4_mult(specular, ibl_specular, temp);
vec4_mult_scalar(temp, spec_coef, temp);
temp = specular * ibl_specular * spec_coef;
shaders_ft.env_vert_set(7, temp);
shaders_ft.env_frag_set(7, temp);
vec4_mult_scalar(ibl_specular, luce_coef, temp);
temp = ibl_specular * luce_coef;
shaders_ft.env_vert_set(8, temp);
shaders_ft.env_frag_set(8, temp);
vec4_mult(specular, ibl_back, temp);
vec4_mult_scalar(temp, spec_coef, temp);
temp = specular * ibl_back * spec_coef;
shaders_ft.env_vert_set(9, temp);
shaders_ft.env_frag_set(9, temp);
@@ -420,12 +411,11 @@ void light_set::data_set(face& face, light_set_id id) {
shaders_ft.env_vert_set(10, position);
shaders_ft.env_frag_set(14, position);
vec4_mult(diffuse, ibl_specular, temp);
temp = diffuse * ibl_specular;
shaders_ft.env_vert_set(11, temp);
shaders_ft.env_frag_set(16, temp);
vec4_mult(specular, ibl_specular, temp);
vec4_mult_scalar(temp, spec_coef, temp);
temp = specular * ibl_specular * spec_coef;
shaders_ft.env_vert_set(12, temp);
shaders_ft.env_frag_set(17, temp);
@@ -439,7 +429,7 @@ void light_set::data_set(face& face, light_set_id id) {
float_t offset = face.get_offset();
float_t v28 = (float_t)(1.0 - exp(offset * -0.44999999)) * 2.0f;
offset = max(offset, 0.0f);
offset = max_def(offset, 0.0f);
shaders_ft.env_vert_set(0x11, v28 * 0.1f, offset * 0.06f, 1.0, 1.0);
if (lights[LIGHT_CHARA_COLOR].get_type() == LIGHT_PARALLEL) {
@@ -466,19 +456,20 @@ void light_set::data_set(face& face, light_set_id id) {
lights[LIGHT_TONE_CURVE].get_diffuse(diffuse);
lights[LIGHT_TONE_CURVE].get_specular(specular);
vec3 tone_curve;
light_tone_curve tone_curve;
lights[LIGHT_TONE_CURVE].get_tone_curve(tone_curve);
tone_curve.y = min(tone_curve.y, 1.0f) - tone_curve.x;
if (tone_curve.y > 0.0f)
tone_curve.y = 1.0f / tone_curve.y;
tone_curve.end_point = min_def(tone_curve.end_point, 1.0f) - tone_curve.start_point;
if (tone_curve.end_point > 0.0f)
tone_curve.end_point = 1.0f / tone_curve.end_point;
else
tone_curve.y = 0.0f;
tone_curve.end_point = 0.0f;
shaders_ft.env_frag_set(36, position);
shaders_ft.env_frag_set(37, ambient);
shaders_ft.env_frag_set(38, diffuse);
shaders_ft.env_frag_set(39, specular);
shaders_ft.env_frag_set(40, tone_curve.x, tone_curve.y, tone_curve.z, 0.0f);
shaders_ft.env_frag_set(40, tone_curve.start_point,
tone_curve.end_point, tone_curve.coefficient, 0.0f);
}
else {
uniform_value[U_TONE_CURVE] = 0;
@@ -493,10 +484,9 @@ void light_set::data_set(face& face, light_set_id id) {
if (fabs(position.x) <= 0.000001f && fabs(position.z) <= 0.000001f && fabs(position.z) <= 0.000001f)
position = { 0.0f, 1.0f, 0.0f, 1.0f };
else {
float_t length;
vec3_length(*(vec3*)&position, length);
float_t length = vec3::length(*(vec3*)&position);
if (length != 0.0f)
vec3_mult_scalar(*(vec3*)&position, 1.0f / length, *(vec3*)&position);
*(vec3*)&position = *(vec3*)&position * (1.0f / length);
}
shaders_ft.env_vert_set(15, position.x, position.y, position.z, 1.0f);
@@ -505,11 +495,10 @@ void light_set::data_set(face& face, light_set_id id) {
if (lights[LIGHT_REFLECT].get_type() == LIGHT_SPOT) {
vec4 spot_direction;
lights[LIGHT_REFLECT].get_spot_direction(*(vec3*)&spot_direction);
vec3_negate(*(vec3*)&spot_direction, *(vec3*)&spot_direction);
*(vec3*)&spot_direction = -*(vec3*)&spot_direction;
light_get_direction_from_position(&spot_direction, &lights[LIGHT_REFLECT], true);
lights[LIGHT_REFLECT].get_position(position);
vec3_dot(*(vec3*)&position, *(vec3*)&spot_direction, spot_direction.w);
spot_direction.w = -spot_direction.w;
spot_direction.w = -vec3::dot(*(vec3*)&position, *(vec3*)&spot_direction);
shaders_ft.env_vert_set(28, spot_direction);
shaders_ft.env_frag_set(22, spot_direction);
@@ -529,27 +518,22 @@ void light_set::data_set(face& face, light_set_id id) {
lights[LIGHT_CHARA].get_ibl_direction(ibl_direction);
lights[LIGHT_CHARA].get_position(position);
float_t length;
vec3_length(*(vec3*)&ibl_direction, length);
float_t length = vec3::length(*(vec3*)&ibl_direction);
if (length >= 0.000001f) {
vec3_mult_scalar(*(vec3*)&ibl_direction, 1.0f / length, *(vec3*)&ibl_direction);
*(vec3*)&ibl_direction = *(vec3*)&ibl_direction * (1.0f / length);
vec3_length(*(vec3*)&position, length);
length = vec3::length(*(vec3*)&position);
if (length >= 0.000001f) {
vec3_mult_scalar(*(vec3*)&position, 1.0f / length, *(vec3*)&position);
*(vec3*)&position = *(vec3*)&position * (1.0f / length);
vec3 axis;
vec3_cross(*(vec3*)&ibl_direction, *(vec3*)&position, axis)
vec3_length(axis, length);
float_t v52;
vec3_dot(*(vec3*)&position, *(vec3*)&ibl_direction, v52);
vec3 axis = vec3::cross(*(vec3*)&ibl_direction, *(vec3*)&position);
length = vec3::length(axis);
float_t v52 = vec3::dot(*(vec3*)&position, *(vec3*)&ibl_direction);
float_t angle = fabsf(atan2f(length, v52));
if (angle >= 0.01f && angle <= 3.131592653589793f) {
if (length != 0.0f)
vec3_mult_scalar(axis, 1.0f / length, axis);
axis *= 1.0f / length;
mat4_from_axis_angle(&axis, -angle, &v63);
mat4_from_axis_angle(&axis, -angle, &v64);
@@ -566,12 +550,11 @@ void light_set::data_set(face& face, light_set_id id) {
static void light_get_direction_from_position(vec4* pos_dir, light_data* light, bool force) {
if (force || light->get_type() == LIGHT_PARALLEL) {
float_t length;
vec3_length(*(vec3*)pos_dir, length);
float_t length = vec3::length(*(vec3*)pos_dir);
if (length <= 0.000001)
*(vec3*)pos_dir = { 0.0f, 1.0f, 0.0f };
else
vec3_mult_scalar(*(vec3*)pos_dir, 1.0f / length, *(vec3*)pos_dir);
*(vec3*)pos_dir = *(vec3*)pos_dir * (1.0f / length);
pos_dir->w = 0.0f;
}
}
src/CRE/light_param/light.hpp
+12 -13
View File
@@ -20,14 +20,12 @@ struct light_data {
vec3 spot_direction;
float_t spot_exponent;
float_t spot_cutoff;
float_t constant;
float_t linear;
float_t quadratic;
light_attenuation attenuation;
vec4 ibl_specular;
vec4 ibl_back;
vec4 ibl_direction;
vec3 tone_curve;
bool clip_plane[4];
light_tone_curve tone_curve;
light_clip_plane clip_plane;
light_data();
@@ -67,9 +65,9 @@ struct light_data {
void set_linear(float_t value);
float_t get_quadratic();
void set_quadratic(float_t value);
void get_attenuation(vec3& value);
void set_attenuation(const vec3& value);
void set_attenuation(const vec3&& value);
void get_attenuation(light_attenuation& value);
void set_attenuation(const light_attenuation& value);
void set_attenuation(const light_attenuation&& value);
void get_ibl_specular(vec4& value);
void set_ibl_specular(const vec4& value);
void set_ibl_specular(const vec4&& value);
@@ -79,11 +77,12 @@ struct light_data {
void get_ibl_direction(vec4& value);
void set_ibl_direction(const vec4& value);
void set_ibl_direction(const vec4&& value);
void get_tone_curve(vec3& value);
void set_tone_curve(const vec3& value);
void set_tone_curve(const vec3&& value);
void get_clip_plane(bool value[4]);
void set_clip_plane(const bool value[4]);
void get_tone_curve(light_tone_curve& value);
void set_tone_curve(const light_tone_curve& value);
void set_tone_curve(const light_tone_curve&& value);
void get_clip_plane(light_clip_plane& value);
void set_clip_plane(const light_clip_plane& value);
void set_clip_plane(const light_clip_plane&& value);
};
struct light_set {
src/CRE/light_param/wind.cpp
+1 -1
View File
@@ -95,7 +95,7 @@ static void wind_ctrl(wind* w) {
vec3 wind_direction = vec3_null;
wind_direction.x = value;
mat4_mult_vec3(&mat, &wind_direction, &wind_direction);
vec3_mult_scalar(wind_direction, w->strength, w->wind_direction);
w->wind_direction = wind_direction * w->strength;
if (w->strength >= 1.0f)
w->strength = 1.0f;
else
src/CRE/lock.cpp
-14
View File
@@ -4,17 +4,3 @@
*/
#include "lock.hpp"
inline void lock_init(lock* l) {
l->init = InitializeCriticalSectionAndSpinCount(&l->cs, 0);
}
inline bool lock_check_init(lock* l) {
return l->init;
}
inline void lock_free(lock* l) {
if (l->init)
DeleteCriticalSection(&l->cs);
l->init = FALSE;
}
src/CRE/lock.hpp
+41 -8
View File
@@ -10,12 +10,49 @@
struct lock {
CRITICAL_SECTION cs;
bool init;
inline lock() : cs() {
init = InitializeCriticalSectionAndSpinCount(&cs, 0);
}
inline ~lock() {
if (init)
DeleteCriticalSection(&cs);
cs = {};
init = false;
}
inline bool check_init() {
if (!this)
return false;
return init;
}
};
struct lock_data {
lock* lock;
void* lock_data;
void(*lock_free)(void* data);
struct lock_uint32_t {
private:
volatile uint32_t value;
public:
inline lock_uint32_t() {
_InterlockedExchange(&value, 0);
}
inline uint32_t get() {
_m_prefetchw(&value);
int32_t v3 = value;
while (true) {
int32_t v4 = v3;
v3 = _InterlockedCompareExchange(&value, v3, v3);
if (v4 == v3)
break;
}
return v3;
}
inline void set(uint32_t value) {
_InterlockedExchange(&this->value, value);
}
};
#define lock_lock(val) \
@@ -28,7 +65,3 @@ if ((val) && (val)->init && TryEnterCriticalSection(&(val)->cs)) {
#define lock_unlock(val) \
LeaveCriticalSection(&(val)->cs); \
}
extern void lock_init(lock* l);
extern bool lock_check_init(lock* l);
extern void lock_free(lock* l);
src/CRE/object.cpp
+285 -343
View File
@@ -10,6 +10,7 @@
#include "data.hpp"
#include "gl_state.hpp"
#include "shader_ft.hpp"
#include "../KKdLib/io/file_stream.hpp"
#include "../KKdLib/io/json.hpp"
#include "../KKdLib/io/path.hpp"
#include "../KKdLib/dds.hpp"
@@ -97,7 +98,7 @@ bool obj_mesh_index_buffer::load(obj_mesh& mesh) {
}
bool ret = load_data((size_t)indices_count * sizeof(uint16_t), indices);
free(indices);
free_def(indices);
return ret;
}
@@ -146,54 +147,6 @@ bool obj_mesh_vertex_buffer::load(obj_mesh& mesh) {
if (!mesh.num_vertex || !mesh.vertex)
return false;
{
const vec4 attib_default = { 0.0f, 0.0f, 0.0f, 1.0f };
obj_vertex_format vertex_format = mesh.vertex_format;
obj_vertex_data* vertex_file = mesh.vertex;
int32_t num_vertex = mesh.num_vertex;
obj_vertex_format _vertex_format = vertex_format;
enum_and(_vertex_format, ~(OBJ_VERTEX_TEXCOORD0 | OBJ_VERTEX_TEXCOORD1 | OBJ_VERTEX_TEXCOORD2
| OBJ_VERTEX_TEXCOORD3 | OBJ_VERTEX_COLOR0 | OBJ_VERTEX_COLOR1 | OBJ_VERTEX_BONE_DATA | OBJ_VERTEX_UNKNOWN));
for (int32_t i = 0; i < num_vertex && _vertex_format != vertex_format; i++) {
if (~_vertex_format & OBJ_VERTEX_TEXCOORD0 && vertex_format & OBJ_VERTEX_TEXCOORD0
&& memcmp(&vertex_file[i].texcoord0, &vec2_null, sizeof(vec2)))
enum_or(_vertex_format, OBJ_VERTEX_TEXCOORD0);
if (~_vertex_format & OBJ_VERTEX_TEXCOORD1 && vertex_format & OBJ_VERTEX_TEXCOORD1
&& memcmp(&vertex_file[i].texcoord1, &vec2_null, sizeof(vec2)))
enum_or(_vertex_format, OBJ_VERTEX_TEXCOORD1);
if (~_vertex_format & OBJ_VERTEX_TEXCOORD2 && vertex_format & OBJ_VERTEX_TEXCOORD2
&& memcmp(&vertex_file[i].texcoord2, &vec2_null, sizeof(vec2)))
enum_or(_vertex_format, OBJ_VERTEX_TEXCOORD2);
if (~_vertex_format & OBJ_VERTEX_TEXCOORD3 && vertex_format & OBJ_VERTEX_TEXCOORD3
&& memcmp(&vertex_file[i].texcoord3, &vec2_null, sizeof(vec2)))
enum_or(_vertex_format, OBJ_VERTEX_TEXCOORD3);
if (~_vertex_format & OBJ_VERTEX_COLOR0 && vertex_format & OBJ_VERTEX_COLOR0
&& memcmp(&vertex_file[i].color0, &vec4_identity, sizeof(vec4)))
enum_or(_vertex_format, OBJ_VERTEX_COLOR0);
if (~_vertex_format & OBJ_VERTEX_COLOR1 && vertex_format & OBJ_VERTEX_COLOR1
&& memcmp(&vertex_file[i].color1, &vec4_identity, sizeof(vec4)))
enum_or(_vertex_format, OBJ_VERTEX_COLOR1);
if (~_vertex_format & OBJ_VERTEX_BONE_DATA && vertex_format & OBJ_VERTEX_BONE_DATA
&& memcmp(&vertex_file[i].bone_index, &vec4i_null, sizeof(vec4i))
&& memcmp(&vertex_file[i].bone_weight, &vec4_null, sizeof(vec4)))
enum_or(_vertex_format, OBJ_VERTEX_BONE_DATA);
if (~_vertex_format & OBJ_VERTEX_UNKNOWN && vertex_format & OBJ_VERTEX_UNKNOWN
&& memcmp(&vertex_file[i].unknown, &attib_default, sizeof(vec4)))
enum_or(_vertex_format, OBJ_VERTEX_UNKNOWN);
}
if (mesh.vertex_format != _vertex_format)
mesh.vertex_format = _vertex_format;
}
size_t size_vertex;
if (!mesh.attrib.m.compressed)
size_vertex = obj_vertex_format_get_vertex_size(mesh.vertex_format);
@@ -279,16 +232,14 @@ bool obj_mesh_vertex_buffer::load(obj_mesh& mesh) {
}
if (vertex_format & OBJ_VERTEX_NORMAL) {
vec3 normal;
vec3_mult_scalar(vertex_file[i].normal, 32727.0f, normal);
vec3 normal = vertex_file[i].normal * 32727.0f;
vec3_to_vec3i16(normal, *(vec3i16*)d);
*(int16_t*)(d + 6) = 0;
d += 8;
}
if (vertex_format & OBJ_VERTEX_TANGENT) {
vec4 tangent = vertex_file[i].tangent;
vec4_mult_scalar(tangent, 32727.0f, tangent);
vec4 tangent = vertex_file[i].tangent * 32727.0f;
vec4_to_vec4i16(tangent, *(vec4i16*)d);
d += 8;
}
@@ -320,8 +271,7 @@ bool obj_mesh_vertex_buffer::load(obj_mesh& mesh) {
}
if (vertex_format & OBJ_VERTEX_BONE_DATA) {
vec4 bone_weight = vertex_file[i].bone_weight;
vec4_mult_scalar(bone_weight, 65535.0f, bone_weight);
vec4 bone_weight = vertex_file[i].bone_weight * 65535.0f;
vec4_to_vec4u16(bone_weight, *(vec4u16*)d);
d += 8;
@@ -335,7 +285,7 @@ bool obj_mesh_vertex_buffer::load(obj_mesh& mesh) {
mesh.size_vertex = (int32_t)size_vertex;
bool ret = load_data(size_vertex * mesh.num_vertex, vertex, mesh.attrib.m.double_buffer ? 2 : 1);
free(vertex);
free_def(vertex);
return ret;
}
@@ -426,7 +376,7 @@ index_buffer_num(), index_buffer_data(), load_count(), modern() {
obj_set_handler::~obj_set_handler() {
for (uint32_t i = 0; i < tex_num; i++)
texture_free(tex_data[i]);
free(tex_data);
free_def(tex_data);
obj_set_handler_index_buffer_free(this);
obj_set_handler_vertex_buffer_free(this);
@@ -534,7 +484,7 @@ void object_material_msgpack_read(const char* path, const char* set_name,
msgpack msg;
stream s;
file_stream s;
s.open(buf, "rb");
io_json_read(s, &msg);
s.close();
@@ -542,7 +492,7 @@ void object_material_msgpack_read(const char* path, const char* set_name,
if (msg.type != MSGPACK_ARRAY)
return;
msgpack_array* ptr = MSGPACK_SELECT(msgpack_array, msg);
msgpack_array* ptr = msg.data.arr;
for (msgpack& i : *ptr) {
msgpack& object = i;
@@ -555,9 +505,9 @@ void object_material_msgpack_read(const char* path, const char* set_name,
if (name_hash != hash_string_murmurhash(obj.name))
continue;
msgpack* materials = object.read("material");
msgpack* materials = object.read_array("material");
if (materials) {
msgpack_array* ptr = MSGPACK_SELECT_PTR(msgpack_array, materials);
msgpack_array* ptr = materials->data.arr;
for (msgpack& j : *ptr) {
msgpack& material = j;
@@ -594,7 +544,7 @@ void object_material_msgpack_read(const char* path, const char* set_name,
msgpack* _shader_name = material.read("shader_name");
if (_shader_name) {
std::string shader_name = _shader_name->read_string();
size_t name_length = min(sizeof(mat.shader.name) - 1, shader_name.size());
size_t name_length = min_def(sizeof(mat.shader.name) - 1, shader_name.size());
memcpy_s(mat.shader.name, sizeof(mat.shader.name) - 1, shader_name.c_str(), name_length);
mat.shader.name[name_length] = 0;
}
@@ -669,7 +619,7 @@ void object_material_msgpack_read(const char* path, const char* set_name,
msgpack* _ex_shader = material.read("ex_shader");
if (_ex_shader) {
std::string shader_name = _ex_shader->read_string();
size_t name_length = min(sizeof(l.ex_shader) - 1, shader_name.size());
size_t name_length = min_def(sizeof(l.ex_shader) - 1, shader_name.size());
memcpy_s(l.ex_shader, sizeof(l.ex_shader) - 1, shader_name.c_str(), name_length);
l.ex_shader[name_length] = 0;
}
@@ -678,13 +628,13 @@ void object_material_msgpack_read(const char* path, const char* set_name,
if (weight)
l.weight = weight->read_float_t();
msgpack* tex_coord_mat = tex->read("tex_coord_mat");
msgpack* tex_coord_mat = tex->read_array("tex_coord_mat");
if (tex_coord_mat) {
msgpack_array* tex_coord_mat_ptr = MSGPACK_SELECT_PTR(msgpack_array, tex_coord_mat);
msgpack_array* tex_coord_mat_ptr = tex_coord_mat->data.arr;
{
msgpack& row0 = tex_coord_mat_ptr->data()[0];
msgpack_array* row0_ptr = MSGPACK_SELECT(msgpack_array, row0);
msgpack_array* row0_ptr = row0.data.arr;
l.tex_coord_mat.row0.x = row0_ptr->data()[0].read_float_t();
l.tex_coord_mat.row0.y = row0_ptr->data()[1].read_float_t();
l.tex_coord_mat.row0.z = row0_ptr->data()[2].read_float_t();
@@ -693,7 +643,7 @@ void object_material_msgpack_read(const char* path, const char* set_name,
{
msgpack& row1 = tex_coord_mat_ptr->data()[1];
msgpack_array* row1_ptr = MSGPACK_SELECT(msgpack_array, row1);
msgpack_array* row1_ptr = row1.data.arr;
l.tex_coord_mat.row1.x = row1_ptr->data()[0].read_float_t();
l.tex_coord_mat.row1.y = row1_ptr->data()[1].read_float_t();
l.tex_coord_mat.row1.z = row1_ptr->data()[2].read_float_t();
@@ -702,7 +652,7 @@ void object_material_msgpack_read(const char* path, const char* set_name,
{
msgpack& row2 = tex_coord_mat_ptr->data()[2];
msgpack_array* row2_ptr = MSGPACK_SELECT(msgpack_array, row2);
msgpack_array* row2_ptr = row2.data.arr;
l.tex_coord_mat.row2.x = row2_ptr->data()[0].read_float_t();
l.tex_coord_mat.row2.y = row2_ptr->data()[1].read_float_t();
l.tex_coord_mat.row2.z = row2_ptr->data()[2].read_float_t();
@@ -711,7 +661,7 @@ void object_material_msgpack_read(const char* path, const char* set_name,
{
msgpack& row3 = tex_coord_mat_ptr->data()[3];
msgpack_array* row3_ptr = MSGPACK_SELECT(msgpack_array, row3);
msgpack_array* row3_ptr = row3.data.arr;
l.tex_coord_mat.row3.x = row3_ptr->data()[0].read_float_t();
l.tex_coord_mat.row3.y = row3_ptr->data()[1].read_float_t();
l.tex_coord_mat.row3.z = row3_ptr->data()[2].read_float_t();
@@ -719,9 +669,9 @@ void object_material_msgpack_read(const char* path, const char* set_name,
}
}
msgpack* reserved = tex->read("reserved");
msgpack* reserved = tex->read_array("reserved");
if (reserved) {
msgpack_array* ptr = MSGPACK_SELECT_PTR(msgpack_array, reserved);
msgpack_array* ptr = reserved->data.arr;
for (int32_t m = 0; m < 8; m++)
l.reserved[m] = ptr->data()[m].read_uint32_t();
}
@@ -811,9 +761,9 @@ void object_material_msgpack_read(const char* path, const char* set_name,
if (bump_depth)
mat.radius = bump_depth->read_float_t();
msgpack* reserved = material.read("reserved");
msgpack* reserved = material.read_array("reserved");
if (reserved) {
msgpack_array* ptr = MSGPACK_SELECT_PTR(msgpack_array, reserved);
msgpack_array* ptr = reserved->data.arr;
for (int32_t m = 0; m < 15; m++)
mat.reserved[m] = ptr->data()[m].read_uint32_t();
}
@@ -822,9 +772,9 @@ void object_material_msgpack_read(const char* path, const char* set_name,
}
}
msgpack* meshes = object.read("mesh");
msgpack* meshes = object.read_array("mesh");
if (meshes) {
msgpack_array* ptr = MSGPACK_SELECT_PTR(msgpack_array, meshes);
msgpack_array* ptr = meshes->data.arr;
for (msgpack& j : *ptr) {
msgpack& _mesh = j;
@@ -837,8 +787,11 @@ void object_material_msgpack_read(const char* path, const char* set_name,
if (name_hash != hash_string_murmurhash(mesh.name))
continue;
msgpack* sub_meshes = _mesh.read("sub_mesh");
msgpack_array* ptr = MSGPACK_SELECT_PTR(msgpack_array, sub_meshes);
msgpack* sub_meshes = _mesh.read_array("sub_mesh");
if (!sub_meshes)
continue;
msgpack_array* ptr = sub_meshes->data.arr;
for (size_t l = 0; l < mesh.num_submesh; l++) {
obj_sub_mesh& sub_mesh = mesh.submesh_array[l];
msgpack& _sub_mesh = ptr->data()[l];
@@ -884,10 +837,10 @@ void object_material_msgpack_read(const char* path, const char* set_name,
sprintf_s(buf, sizeof(buf), "%s\\%s\\config_tex.json", path, set_name_buf);
if (!path_check_file_exists(buf))
return;
msgpack msg;
stream s;
file_stream s;
s.open(buf, "rb");
io_json_read(s, &msg);
s.close();
@@ -895,10 +848,10 @@ void object_material_msgpack_read(const char* path, const char* set_name,
if (msg.type != MSGPACK_MAP)
return;
msgpack* add = msg.read("Add");
msgpack* add = msg.read_array("Add");
if (add) {
std::vector<uint32_t> ids;
msgpack_array* ptr = MSGPACK_SELECT_PTR(msgpack_array, add);
msgpack_array* ptr = add->data.arr;
for (msgpack& i : *ptr) {
std::string name = i.read_string();
if (!name.size())
@@ -934,8 +887,8 @@ void object_material_msgpack_read(const char* path, const char* set_name,
do
for (uint32_t i = 0; i < tex->mipmaps_count; i++) {
txp_mipmap tex_mip;
tex_mip.width = max(d.width >> i, 1);
tex_mip.height = max(d.height >> i, 1);
tex_mip.width = max_def(d.width >> i, 1);
tex_mip.height = max_def(d.height >> i, 1);
tex_mip.format = d.format;
uint32_t size = txp::get_size(tex_mip.format, tex_mip.width, tex_mip.height);
@@ -954,7 +907,7 @@ void object_material_msgpack_read(const char* path, const char* set_name,
if (set->tex_id_num != tex_id_num) {
uint32_t* tex_id_data = force_malloc_s(uint32_t, tex_id_num);
memmove(tex_id_data, set->tex_id_data, sizeof(uint32_t) * set->tex_id_num);
free(set->tex_id_data);
free_def(set->tex_id_data);
memmove(&tex_id_data[set->tex_id_num], ids.data(), sizeof(uint32_t) * (tex_id_num - set->tex_id_num));
@@ -965,9 +918,9 @@ void object_material_msgpack_read(const char* path, const char* set_name,
}
msgpack* replace = msg.read("Replace");
msgpack* replace = msg.read_array("Replace");
if (replace) {
msgpack_array* ptr = MSGPACK_SELECT_PTR(msgpack_array, replace);
msgpack_array* ptr = replace->data.arr;
for (msgpack& i : *ptr) {
std::string name = i.read_string();
if (!name.size())
@@ -1005,8 +958,8 @@ void object_material_msgpack_read(const char* path, const char* set_name,
do
for (uint32_t i = 0; i < tex->mipmaps_count; i++) {
txp_mipmap tex_mip;
tex_mip.width = max(d.width >> i, 1);
tex_mip.height = max(d.height >> i, 1);
tex_mip.width = max_def(d.width >> i, 1);
tex_mip.height = max_def(d.height >> i, 1);
tex_mip.format = d.format;
uint32_t size = txp::get_size(tex_mip.format, tex_mip.width, tex_mip.height);
@@ -1031,290 +984,282 @@ void object_material_msgpack_write(const char* path, const char* set_name, uint3
if (!path_check_directory_exists(buf) && !CreateDirectoryA(buf, 0))
return;
msgpack_array objects;
objects.resize(obj_set->obj_num);
msgpack_array objects(obj_set->obj_num);
for (uint32_t i = 0; i < obj_set->obj_num; i++) {
obj& obj = obj_set->obj_data[i];
msgpack& object = objects.data()[i];
object = msgpack(0, false, 0);
object.append(msgpack("name", obj.name));
object.append(msgpack("material", true, obj.num_material));
object.append(msgpack("mesh", true, obj.num_mesh));
object = msgpack(msgpack_map());
object.append("name", obj.name);
msgpack* materials = object.get_by_name("material");
msgpack_array* ptr = MSGPACK_SELECT_PTR(msgpack_array, materials);
for (size_t j = 0; j < obj.num_material; j++) {
obj_material& mat = obj.material_array[j].material;
msgpack& material = ptr->data()[j];
material = msgpack(0, false, 0);
msgpack* materials = object.append("material", msgpack_array());
if (materials) {
msgpack_array* ptr = materials->data.arr;
ptr->resize(obj.num_material);
for (size_t j = 0; j < obj.num_material; j++) {
obj_material& mat = obj.material_array[j].material;
msgpack& material = ptr->data()[j];
material = msgpack_map();
{
msgpack shader_compo = msgpack("shader_compo", false, 0);
shader_compo.append({ "color", (bool)mat.shader_compo.m.color });
shader_compo.append({ "color_a", (bool)mat.shader_compo.m.color_a });
shader_compo.append({ "color_l1", (bool)mat.shader_compo.m.color_l1 });
shader_compo.append({ "color_l1_a", (bool)mat.shader_compo.m.color_l1_a });
shader_compo.append({ "color_l2", (bool)mat.shader_compo.m.color_l2 });
shader_compo.append({ "color_l2_a", (bool)mat.shader_compo.m.color_l2_a });
shader_compo.append({ "transparency", (bool)mat.shader_compo.m.transparency });
shader_compo.append({ "specular", (bool)mat.shader_compo.m.specular });
shader_compo.append({ "normal_01", (bool)mat.shader_compo.m.normal_01 });
shader_compo.append({ "normal_02", (bool)mat.shader_compo.m.normal_02 });
shader_compo.append({ "envmap", (bool)mat.shader_compo.m.envmap });
shader_compo.append({ "color_l3", (bool)mat.shader_compo.m.color_l3 });
shader_compo.append({ "color_l3_a", (bool)mat.shader_compo.m.color_l3_a });
shader_compo.append({ "translucency", (bool)mat.shader_compo.m.translucency });
shader_compo.append({ "flag_14", (bool)mat.shader_compo.m.flag_14 });
shader_compo.append({ "override_ibl", (bool)mat.shader_compo.m.override_ibl });
shader_compo.append({ "dummy", mat.shader_compo.m.dummy });
material.append(shader_compo);
}
msgpack* shader_compo = material.append("shader_compo", msgpack_map());
if (shader_compo) {
shader_compo->append("color", (bool)mat.shader_compo.m.color);
shader_compo->append("color_a", (bool)mat.shader_compo.m.color_a);
shader_compo->append("color_l1", (bool)mat.shader_compo.m.color_l1);
shader_compo->append("color_l1_a", (bool)mat.shader_compo.m.color_l1_a);
shader_compo->append("color_l2", (bool)mat.shader_compo.m.color_l2);
shader_compo->append("color_l2_a", (bool)mat.shader_compo.m.color_l2_a);
shader_compo->append("transparency", (bool)mat.shader_compo.m.transparency);
shader_compo->append("specular", (bool)mat.shader_compo.m.specular);
shader_compo->append("normal_01", (bool)mat.shader_compo.m.normal_01);
shader_compo->append("normal_02", (bool)mat.shader_compo.m.normal_02);
shader_compo->append("envmap", (bool)mat.shader_compo.m.envmap);
shader_compo->append("color_l3", (bool)mat.shader_compo.m.color_l3);
shader_compo->append("color_l3_a", (bool)mat.shader_compo.m.color_l3_a);
shader_compo->append("translucency", (bool)mat.shader_compo.m.translucency);
shader_compo->append("flag_14", (bool)mat.shader_compo.m.flag_14);
shader_compo->append("override_ibl", (bool)mat.shader_compo.m.override_ibl);
shader_compo->append("dummy", mat.shader_compo.m.dummy);
}
material.append({ "shader_name", mat.shader.name });
material.append("shader_name", mat.shader.name);
{
msgpack shader_info = msgpack("shader_info", false, 0);
shader_info.append({ "vtx_trans_type", mat.shader_info.m.vtx_trans_type });
shader_info.append({ "col_src", mat.shader_info.m.col_src });
shader_info.append({ "is_lgt_diffuse", (bool)mat.shader_info.m.is_lgt_diffuse });
shader_info.append({ "is_lgt_specular", (bool)mat.shader_info.m.is_lgt_specular });
shader_info.append({ "is_lgt_per_pixel",(bool)mat.shader_info.m.is_lgt_per_pixel });
shader_info.append({ "is_lgt_double", (bool)mat.shader_info.m.is_lgt_double });
shader_info.append({ "bump_map_type", mat.shader_info.m.bump_map_type });
shader_info.append({ "fresnel_type", mat.shader_info.m.fresnel_type });
shader_info.append({ "line_light", mat.shader_info.m.line_light });
shader_info.append({ "recieve_shadow", (bool)mat.shader_info.m.recieve_shadow });
shader_info.append({ "cast_shadow", (bool)mat.shader_info.m.cast_shadow });
shader_info.append({ "specular_quality", mat.shader_info.m.specular_quality });
shader_info.append({ "aniso_direction", mat.shader_info.m.aniso_direction });
shader_info.append({ "dummy", mat.shader_info.m.dummy });
material.append(shader_info);
}
msgpack* shader_info = material.append("shader_info", msgpack_map());
if (shader_info) {
shader_info->append("vtx_trans_type", mat.shader_info.m.vtx_trans_type);
shader_info->append("col_src", mat.shader_info.m.col_src);
shader_info->append("is_lgt_diffuse", (bool)mat.shader_info.m.is_lgt_diffuse);
shader_info->append("is_lgt_specular", (bool)mat.shader_info.m.is_lgt_specular);
shader_info->append("is_lgt_per_pixel", (bool)mat.shader_info.m.is_lgt_per_pixel);
shader_info->append("is_lgt_double", (bool)mat.shader_info.m.is_lgt_double);
shader_info->append("bump_map_type", mat.shader_info.m.bump_map_type);
shader_info->append("fresnel_type", mat.shader_info.m.fresnel_type);
shader_info->append("line_light", mat.shader_info.m.line_light);
shader_info->append("recieve_shadow", (bool)mat.shader_info.m.recieve_shadow);
shader_info->append("cast_shadow", (bool)mat.shader_info.m.cast_shadow);
shader_info->append("specular_quality", mat.shader_info.m.specular_quality);
shader_info->append("aniso_direction", mat.shader_info.m.aniso_direction);
shader_info->append("dummy", mat.shader_info.m.dummy);
}
{
msgpack texdata = msgpack("texdata", false, 0);
for (obj_material_texture_data& k : mat.texdata) {
if (!k.tex_index || k.tex_index == -1
|| k.tex_index == hash_murmurhash_empty || k.tex_index == hash_murmurhash_null)
continue;
msgpack* texdata = material.append("texdata", msgpack_map());
if (texdata) {
for (obj_material_texture_data& k : mat.texdata) {
if (!k.tex_index || k.tex_index == -1
|| k.tex_index == hash_murmurhash_empty || k.tex_index == hash_murmurhash_null)
continue;
sprintf_s(buf, sizeof(buf), "%d", (int32_t)(&k - mat.texdata));
msgpack tex = msgpack(buf, false, 0);
sprintf_s(buf, sizeof(buf), "%d", (int32_t)(&k - mat.texdata));
msgpack& tex = *texdata->append(buf, msgpack_map());
{
msgpack attrib = msgpack("attrib", false, 0);
attrib.append({ "repeat_u", (bool)k.attrib.m.repeat_u });
attrib.append({ "repeat_v", (bool)k.attrib.m.repeat_v });
attrib.append({ "mirror_u", (bool)k.attrib.m.mirror_u });
attrib.append({ "mirror_v", (bool)k.attrib.m.mirror_v });
attrib.append({ "ignore_alpha", (bool)k.attrib.m.ignore_alpha });
attrib.append({ "blend", k.attrib.m.blend });
attrib.append({ "alpha_blend", k.attrib.m.alpha_blend });
attrib.append({ "border", (bool)k.attrib.m.border });
attrib.append({ "clamp2edge", (bool)k.attrib.m.clamp2edge });
attrib.append({ "filter", k.attrib.m.filter });
attrib.append({ "mipmap", k.attrib.m.mipmap });
attrib.append({ "mipmap_bias", k.attrib.m.mipmap_bias });
attrib.append({ "flag_29", (bool)k.attrib.m.flag_29 });
attrib.append({ "anisotropic_filter", k.attrib.m.anisotropic_filter });
tex.append(attrib);
}
tex.append({ "tex_name", tex_db->get_texture_name(k.tex_index) });
{
msgpack shader_info = msgpack("shader_info", false, 0);
shader_info.append({ "tex_type", k.shader_info.m.tex_type });
shader_info.append({ "uv_idx", k.shader_info.m.uv_idx });
shader_info.append({ "texcoord_trans", k.shader_info.m.texcoord_trans });
shader_info.append({ "dummy", k.shader_info.m.dummy });
tex.append(shader_info);
}
tex.append({ "ex_shader", k.ex_shader });
tex.append({ "weight", k.weight });
{
msgpack tex_coord_mat = msgpack("tex_coord_mat", true, 4);
msgpack_array* tex_coord_mat_ptr = MSGPACK_SELECT(msgpack_array, tex_coord_mat);
{
msgpack& row0 = tex_coord_mat_ptr->data()[0];
row0 = msgpack(0, true, 4);
msgpack_array* row0_ptr = MSGPACK_SELECT(msgpack_array, row0);
row0_ptr->data()[0] = { 0, k.tex_coord_mat.row0.x };
row0_ptr->data()[1] = { 0, k.tex_coord_mat.row0.y };
row0_ptr->data()[2] = { 0, k.tex_coord_mat.row0.z };
row0_ptr->data()[3] = { 0, k.tex_coord_mat.row0.w };
msgpack* attrib = tex.append("attrib", msgpack_map());
if (attrib) {
attrib->append("repeat_u", (bool)k.attrib.m.repeat_u);
attrib->append("repeat_v", (bool)k.attrib.m.repeat_v);
attrib->append("mirror_u", (bool)k.attrib.m.mirror_u);
attrib->append("mirror_v", (bool)k.attrib.m.mirror_v);
attrib->append("ignore_alpha", (bool)k.attrib.m.ignore_alpha);
attrib->append("blend", k.attrib.m.blend);
attrib->append("alpha_blend", k.attrib.m.alpha_blend);
attrib->append("border", (bool)k.attrib.m.border);
attrib->append("clamp2edge", (bool)k.attrib.m.clamp2edge);
attrib->append("filter", k.attrib.m.filter);
attrib->append("mipmap", k.attrib.m.mipmap);
attrib->append("mipmap_bias", k.attrib.m.mipmap_bias);
attrib->append("flag_29", (bool)k.attrib.m.flag_29);
attrib->append("anisotropic_filter", k.attrib.m.anisotropic_filter);
}
{
msgpack& row1 = tex_coord_mat_ptr->data()[1];
row1 = msgpack(0, true, 4);
msgpack_array* row1_ptr = MSGPACK_SELECT(msgpack_array, row1);
row1_ptr->data()[0] = { 0, k.tex_coord_mat.row1.x };
row1_ptr->data()[1] = { 0, k.tex_coord_mat.row1.y };
row1_ptr->data()[2] = { 0, k.tex_coord_mat.row1.z };
row1_ptr->data()[3] = { 0, k.tex_coord_mat.row1.w };
tex.append("tex_name", tex_db->get_texture_name(k.tex_index));
msgpack* shader_info = tex.append("shader_info", msgpack_map());
if (shader_info) {
shader_info->append("tex_type", k.shader_info.m.tex_type);
shader_info->append("uv_idx", k.shader_info.m.uv_idx);
shader_info->append("texcoord_trans", k.shader_info.m.texcoord_trans);
shader_info->append("dummy", k.shader_info.m.dummy);
}
{
msgpack& row2 = tex_coord_mat_ptr->data()[2];
row2 = msgpack(0, true, 4);
msgpack_array* row2_ptr = MSGPACK_SELECT(msgpack_array, row2);
row2_ptr->data()[0] = { 0, k.tex_coord_mat.row2.x };
row2_ptr->data()[1] = { 0, k.tex_coord_mat.row2.y };
row2_ptr->data()[2] = { 0, k.tex_coord_mat.row2.z };
row2_ptr->data()[3] = { 0, k.tex_coord_mat.row2.w };
tex.append("ex_shader", k.ex_shader);
tex.append("weight", k.weight);
msgpack* tex_coord_mat = tex.append("tex_coord_mat", msgpack_array());
if (tex_coord_mat) {
msgpack_array* tex_coord_mat_ptr = tex_coord_mat->data.arr;
tex_coord_mat_ptr->resize(4);
{
msgpack& row0 = tex_coord_mat_ptr->data()[0];
row0 = msgpack_array();
msgpack_array* row0_ptr = row0.data.arr;
row0_ptr->resize(4);
row0_ptr->data()[0] = k.tex_coord_mat.row0.x;
row0_ptr->data()[1] = k.tex_coord_mat.row0.y;
row0_ptr->data()[2] = k.tex_coord_mat.row0.z;
row0_ptr->data()[3] = k.tex_coord_mat.row0.w;
}
{
msgpack& row1 = tex_coord_mat_ptr->data()[1];
row1 = msgpack_array();
msgpack_array* row1_ptr = row1.data.arr;
row1_ptr->resize(4);
row1_ptr->data()[0] = k.tex_coord_mat.row1.x;
row1_ptr->data()[1] = k.tex_coord_mat.row1.y;
row1_ptr->data()[2] = k.tex_coord_mat.row1.z;
row1_ptr->data()[3] = k.tex_coord_mat.row1.w;
}
{
msgpack& row2 = tex_coord_mat_ptr->data()[2];
row2 = msgpack_array();
msgpack_array* row2_ptr = row2.data.arr;
row2_ptr->resize(4);
row2_ptr->data()[0] = k.tex_coord_mat.row2.x;
row2_ptr->data()[1] = k.tex_coord_mat.row2.y;
row2_ptr->data()[2] = k.tex_coord_mat.row2.z;
row2_ptr->data()[3] = k.tex_coord_mat.row2.w;
}
{
msgpack& row3 = tex_coord_mat_ptr->data()[3];
row3 = msgpack_array();
msgpack_array* row3_ptr = row3.data.arr;
row3_ptr->resize(4);
row3_ptr->data()[0] = k.tex_coord_mat.row3.x;
row3_ptr->data()[1] = k.tex_coord_mat.row3.y;
row3_ptr->data()[2] = k.tex_coord_mat.row3.z;
row3_ptr->data()[3] = k.tex_coord_mat.row3.w;
}
}
{
msgpack& row3 = tex_coord_mat_ptr->data()[3];
row3 = msgpack(0, true, 4);
msgpack_array* row3_ptr = MSGPACK_SELECT(msgpack_array, row3);
row3_ptr->data()[0] = { 0, k.tex_coord_mat.row3.x };
row3_ptr->data()[1] = { 0, k.tex_coord_mat.row3.y };
row3_ptr->data()[2] = { 0, k.tex_coord_mat.row3.z };
row3_ptr->data()[3] = { 0, k.tex_coord_mat.row3.w };
msgpack* reserved = tex.append("reserved", msgpack_array());
if (reserved) {
msgpack_array* ptr = reserved->data.arr;
ptr->resize(8);
for (int32_t l = 0; l < 8; l++)
ptr->data()[l] = k.reserved[l];
}
}
}
tex.append(tex_coord_mat);
msgpack* attrib = material.append("attrib", msgpack_map());
if (attrib) {
attrib->append("alpha_texture", (bool)mat.attrib.m.alpha_texture);
attrib->append("alpha_material", (bool)mat.attrib.m.alpha_material);
attrib->append("punch_through", (bool)mat.attrib.m.punch_through);
attrib->append("double_sided", (bool)mat.attrib.m.double_sided);
attrib->append("normal_dir_light", (bool)mat.attrib.m.normal_dir_light);
attrib->append("src_blend_factor", mat.attrib.m.src_blend_factor);
attrib->append("dst_blend_factor", mat.attrib.m.dst_blend_factor);
attrib->append("blend_operation", mat.attrib.m.blend_operation);
attrib->append("zbias", mat.attrib.m.zbias);
attrib->append("no_fog", (bool)mat.attrib.m.no_fog);
attrib->append("translucent_priority", mat.attrib.m.translucent_priority);
attrib->append("has_fog_height", (bool)mat.attrib.m.has_fog_height);
attrib->append("flag_28", (bool)mat.attrib.m.flag_28);
attrib->append("fog_height", (bool)mat.attrib.m.fog_height);
attrib->append("flag_30", (bool)mat.attrib.m.flag_30);
attrib->append("flag_31", (bool)mat.attrib.m.flag_31);
}
msgpack* color = material.append("color", msgpack_map());
if (color) {
msgpack* diffuse = color->append("diffuse", msgpack_map());
if (diffuse) {
diffuse->append("r", mat.color.diffuse.x);
diffuse->append("g", mat.color.diffuse.y);
diffuse->append("b", mat.color.diffuse.z);
diffuse->append("a", mat.color.diffuse.w);
}
{
msgpack reserved = msgpack("reserved", true, 8);
msgpack_array* ptr = MSGPACK_SELECT(msgpack_array, reserved);
for (int32_t l = 0; l < 8; l++)
ptr->data()[l] = { 0, k.reserved[l] };
tex.append(reserved);
msgpack* ambient = color->append("ambient", msgpack_map());
if (ambient) {
ambient->append("r", mat.color.ambient.x);
ambient->append("g", mat.color.ambient.y);
ambient->append("b", mat.color.ambient.z);
ambient->append("a", mat.color.ambient.w);
}
texdata.append(tex);
msgpack* specular = color->append("specular", msgpack_map());
if (specular) {
specular->append("r", mat.color.specular.x);
specular->append("g", mat.color.specular.y);
specular->append("b", mat.color.specular.z);
specular->append("a", mat.color.specular.w);
}
msgpack* emission = color->append("emission", msgpack_map());
if (emission) {
emission->append("r", mat.color.emission.x);
emission->append("g", mat.color.emission.y);
emission->append("b", mat.color.emission.z);
emission->append("a", mat.color.emission.w);
}
color->append("shininess", mat.color.shininess);
color->append("intensity", mat.color.intensity);
}
material.append(texdata);
}
{
msgpack attrib = msgpack("attrib", false, 0);
attrib.append({ "alpha_texture", (bool)mat.attrib.m.alpha_texture });
attrib.append({ "alpha_material", (bool)mat.attrib.m.alpha_material });
attrib.append({ "punch_through", (bool)mat.attrib.m.punch_through });
attrib.append({ "double_sided", (bool)mat.attrib.m.double_sided });
attrib.append({ "normal_dir_light", (bool)mat.attrib.m.normal_dir_light });
attrib.append({ "src_blend_factor", mat.attrib.m.src_blend_factor });
attrib.append({ "dst_blend_factor", mat.attrib.m.dst_blend_factor });
attrib.append({ "blend_operation", mat.attrib.m.blend_operation });
attrib.append({ "zbias", mat.attrib.m.zbias });
attrib.append({ "no_fog", (bool)mat.attrib.m.no_fog });
attrib.append({ "translucent_priority", mat.attrib.m.translucent_priority });
attrib.append({ "has_fog_height", (bool)mat.attrib.m.has_fog_height });
attrib.append({ "flag_28", (bool)mat.attrib.m.flag_28 });
attrib.append({ "fog_height", (bool)mat.attrib.m.fog_height });
attrib.append({ "flag_30", (bool)mat.attrib.m.flag_30 });
attrib.append({ "flag_31", (bool)mat.attrib.m.flag_31 });
material.append(attrib);
}
{
msgpack color = msgpack("color", false, 0);
{
msgpack diffuse = msgpack("diffuse", false, 0);
diffuse.append({ "r", mat.color.diffuse.x });
diffuse.append({ "g", mat.color.diffuse.y });
diffuse.append({ "b", mat.color.diffuse.z });
diffuse.append({ "a", mat.color.diffuse.w });
color.append(diffuse);
msgpack* center = material.append("center", msgpack_map());
if (center) {
center->append("x", mat.center.x);
center->append("y", mat.center.y);
center->append("z", mat.center.z);
}
{
msgpack ambient = msgpack("ambient", false, 0);
ambient.append({ "r", mat.color.ambient.x });
ambient.append({ "g", mat.color.ambient.y });
ambient.append({ "b", mat.color.ambient.z });
ambient.append({ "a", mat.color.ambient.w });
color.append(ambient);
material.append("radius", mat.radius);
material.append("name", mat.name);
material.append("bump_depth", mat.bump_depth);
msgpack* reserved = material.append("reserved", msgpack_array());
if (reserved) {
msgpack_array* ptr = reserved->data.arr;
ptr->resize(15);
for (int32_t k = 0; k < 15; k++)
ptr->data()[k] = mat.reserved[k];
}
{
msgpack specular = msgpack("specular", false, 0);
specular.append({ "r", mat.color.specular.x });
specular.append({ "g", mat.color.specular.y });
specular.append({ "b", mat.color.specular.z });
specular.append({ "a", mat.color.specular.w });
color.append(specular);
}
{
msgpack emission = msgpack("emission", false, 0);
emission.append({ "r", mat.color.emission.x });
emission.append({ "g", mat.color.emission.y });
emission.append({ "b", mat.color.emission.z });
emission.append({ "a", mat.color.emission.w });
color.append(emission);
}
color.append({ "shininess", mat.color.shininess });
color.append({ "intensity", mat.color.intensity });
material.append(color);
}
{
msgpack center = msgpack("center", false, 0);
center.append({ "x", mat.center.x });
center.append({ "y", mat.center.y });
center.append({ "z", mat.center.z });
material.append(center);
}
material.append({ "radius", mat.radius });
material.append({ "name", mat.name });
material.append({ "bump_depth", mat.bump_depth });
{
msgpack reserved = msgpack("reserved", true, 15);
msgpack_array* ptr = MSGPACK_SELECT(msgpack_array, reserved);
for (int32_t k = 0; k < 15; k++)
ptr->data()[k] = { 0, mat.reserved[k] };
material.append(reserved);
}
}
msgpack* meshes = object.get_by_name("mesh");
ptr = MSGPACK_SELECT_PTR(msgpack_array, meshes);
for (size_t j = 0; j < obj.num_mesh; j++) {
obj_mesh& mesh = obj.mesh_array[j];
msgpack& _mesh = ptr->data()[j];
_mesh = msgpack(0, false, 0);
msgpack* meshes = object.append("mesh", msgpack_array());
if (meshes) {
msgpack_array* ptr = meshes->data.arr;
ptr->resize(obj.num_mesh);
for (size_t j = 0; j < obj.num_mesh; j++) {
obj_mesh& mesh = obj.mesh_array[j];
msgpack& _mesh = ptr->data()[j];
_mesh = msgpack_map();
_mesh.append(msgpack("name", mesh.name));
_mesh.append(msgpack("sub_mesh", true, mesh.num_submesh));
_mesh.append("name", mesh.name);
msgpack* sub_meshes = _mesh.get_by_name("sub_mesh");
msgpack_array* ptr = MSGPACK_SELECT_PTR(msgpack_array, sub_meshes);
for (size_t k = 0; k < mesh.num_submesh; k++) {
obj_sub_mesh& sub_mesh = mesh.submesh_array[k];
msgpack& _sub_mesh = ptr->data()[k];
_sub_mesh = msgpack(0, false, 0);
msgpack* sub_meshes = _mesh.append("sub_mesh", msgpack_array());
if (sub_meshes) {
msgpack_array* ptr = sub_meshes->data.arr;
ptr->resize(mesh.num_submesh);
for (size_t k = 0; k < mesh.num_submesh; k++) {
obj_sub_mesh& sub_mesh = mesh.submesh_array[k];
msgpack& _sub_mesh = ptr->data()[k];
_sub_mesh = msgpack_map();
{
msgpack attrib = msgpack("attrib", false, 0);
attrib.append({ "recieve_shadow", (bool)sub_mesh.attrib.m.recieve_shadow });
attrib.append({ "cast_shadow", (bool)sub_mesh.attrib.m.cast_shadow });
_sub_mesh.append(attrib);
{
msgpack attrib = msgpack_map();
attrib.append("recieve_shadow", (bool)sub_mesh.attrib.m.recieve_shadow);
attrib.append("cast_shadow", (bool)sub_mesh.attrib.m.cast_shadow);
_sub_mesh.append("attrib", attrib);
}
}
}
}
}
}
msgpack msg = msgpack(0, true, objects);
msgpack msg = objects;
sprintf_s(buf, sizeof(buf), "%s\\%s\\config.json", path, set_name);
stream s;
file_stream s;
s.open(buf, "wb");
io_json_write(s, &msg);
s.close();
@@ -1338,7 +1283,7 @@ void object_material_msgpack_write(const char* path, const char* set_name, uint3
uint32_t index = 0;
do
for (uint32_t j = 0; j < tex.mipmaps_count; j++) {
uint32_t size = txp::get_size(format, max(width >> j, 1), max(height >> j, 1));
uint32_t size = txp::get_size(format, max_def(width >> j, 1), max_def(height >> j, 1));
void* data = force_malloc(size);
memcpy(data, tex.mipmaps[index].data.data(), size);
d.data.push_back(data);
@@ -2048,7 +1993,7 @@ inline void object_storage_unload_set(object_database* obj_db, const char* name)
int32_t tex_num = handler->tex_num;
for (int32_t i = 0; i < tex_num; i++)
texture_free(tex_data[i]);
free(tex_data);
free_def(tex_data);
handler->tex_data = 0;
handler->tex_num = 0;
@@ -2080,7 +2025,7 @@ inline void object_storage_unload_set(uint32_t set_id) {
int32_t tex_num = handler->tex_num;
for (int32_t i = 0; i < tex_num; i++)
texture_free(tex_data[i]);
free(tex_data);
free_def(tex_data);
handler->tex_data = 0;
handler->tex_num = 0;
@@ -2128,21 +2073,18 @@ static void obj_set_handler_calc_axis_aligned_bounding_box(obj_set_handler* hand
continue;
vec3 pos = vertex[indices[l]].position;
vec3_min(_min, pos, _min);
vec3_max(_max, pos, _max);
_min = vec3::min(_min, pos);
_max = vec3::max(_max, pos);
}
else
for (uint32_t l = 0; l < indices_count; l++) {
vec3 pos = vertex[indices[l]].position;
vec3_min(_min, pos, _min);
vec3_max(_max, pos, _max);
_min = vec3::min(_min, pos);
_max = vec3::max(_max, pos);
}
vec3 center;
vec3 size;
vec3_add(_max, _min, center);
vec3_mult_scalar(center, 0.5f, center);
vec3_sub(_max, center, size);
vec3 center = (_max + _min) * 0.5f;
vec3 size = _max - center;
sub_mesh.axis_aligned_bounding_box.center = center;
sub_mesh.axis_aligned_bounding_box.size = size;
}
@@ -2320,7 +2262,7 @@ inline static void obj_skin_block_node_load(obj_skin_block_node* node,
}
inline static void obj_skin_block_node_free(obj_skin_block_node* node) {
free(node->parent_name);
free_def(node->parent_name);
}
inline static size_t obj_vertex_format_get_vertex_size(obj_vertex_format format) {
src/CRE/ogg_vorbis.cpp
+583
View File
@@ -0,0 +1,583 @@
/*
by korenkonder
GitHub/GitLab: korenkonder
*/
#include "ogg_vorbis.hpp"
#include "../KKdLib/str_utils.hpp"
#include "../KKdLib/vec.hpp"
#include <intrin.h>
static int32_t ogg_file_counter = 0;
static int32_t ogg_file_handler_counter = 0;
OggFileBufferChannelData::OggFileBufferChannelData() : left(), right() {
}
OggFileBufferData::OggFileBufferData() {
time = -1.0;
}
OggFileBuffer::OggFileBuffer() : first_sample(), last_sample() {
size = 0x40999;
data.resize(size);
}
OggFileBuffer::~OggFileBuffer() {
}
void OggFileBuffer::Reset() {
data.clear();
data.resize(size);
first_sample = 0;
last_sample = 0;
}
OggFile::OggFile() : file(), info(), comments() {
loop_begin = -1;
loop_end = -1;
thread = new std::thread(OggFile::ThreadMain, this);
if (thread) {
wchar_t buf[0x80];
swprintf_s(buf, sizeof(buf) / sizeof(wchar_t), L"Ogg File #%d", ogg_file_counter++);
SetThreadDescription((HANDLE)thread->native_handle(), buf);
}
}
OggFile::~OggFile() {
Reset();
if (thread) {
thread_state.set(1);
thread->join();
delete thread;
thread = 0;
}
}
void OggFile::Ctrl(size_t samples_count) {
std::unique_lock<std::mutex> u_lock(file_mtx);
if (!file || !info || !comments)
return;
OggFileBufferData* _buffer_data = buffer.data.data();
size_t _buffer_size = buffer.data.size();
while (samples_count) {
size_t free_samples_count = GetBufferFreeSamplesCount();
if (free_samples_count <= 0)
break;
int64_t samples_to_read = min_def(samples_count, free_samples_count);
int64_t position = ov_pcm_tell(file);
double_t time_start = ov_time_tell(file);
if (loop_end >= 0 && position + samples_to_read > loop_end) {
if (loop_end - position <= 0) {
size_t seek = 0i64;
if (loop_begin >= 0)
seek = loop_begin;
ov_pcm_seek_lap(file, seek);
}
else
samples_to_read = loop_end - position;
}
float_t** pcm_channels = 0;
int32_t bitstream = 0;
size_t samples_read = ov_read_float(file, &pcm_channels, (int32_t)samples_to_read, &bitstream);
if (samples_read < 1 || !pcm_channels)
break;
int32_t channels = info->channels;
bool mono = channels == 1;
std::unique_lock<std::mutex> u_lock(mtx);
for (size_t i = 0; i < samples_read; i++) {
OggFileBufferData data;
data.time = (double_t)(int32_t)i / (double_t)info->rate + time_start;
if (channels > 0) {
if (mono) {
float_t value = pcm_channels[0][i];
data.channel_pair[0].left = value;
data.channel_pair[0].right = value;
}
else {
float_t** _pcm_channels = pcm_channels;
for (int32_t j = 0; j < channels; j += 2, _pcm_channels += 2) {
int32_t pair = j / 2;
if (pair >= 4)
break;
data.channel_pair[pair].left = _pcm_channels[0][i];
data.channel_pair[pair].right = _pcm_channels[1][i];
}
}
}
if (_buffer_size) {
size_t last_sample = buffer.last_sample;
size_t new_last_sample = last_sample + 1;
if (new_last_sample >= buffer.size)
new_last_sample = 0;
if (new_last_sample != buffer.first_sample) {
_buffer_data[last_sample] = data;
buffer.last_sample = new_last_sample;
}
}
}
samples_count -= samples_read;
}
}
size_t OggFile::FillBufferData(OggFileBufferData* buffer_data, size_t samples_count) {
std::unique_lock<std::mutex> u_lock(mtx);
OggFileBufferData* _buffer_data = buffer.data.data();
size_t _buffer_size = buffer.data.size();
size_t _samples_count = 0;
for (; samples_count && buffer.first_sample != buffer.last_sample;
samples_count--, buffer_data++, _samples_count++) {
if (_buffer_size)
*buffer_data = _buffer_data[buffer.first_sample];
else
*buffer_data = {};
if (_buffer_size) {
size_t first_sample = buffer.first_sample;
if (first_sample != buffer.last_sample) {
_buffer_data[first_sample++] = {};
if (first_sample >= buffer.size)
first_sample = 0;
buffer.first_sample = first_sample;
}
}
}
return _samples_count;
}
size_t OggFile::GetBufferFreeSamplesCount() {
std::unique_lock<std::mutex> u_lock(mtx);
size_t last_sample = buffer.last_sample;
size_t first_sample = buffer.first_sample;
size_t samples_count;
if (last_sample < first_sample)
samples_count = buffer.size - first_sample + last_sample;
else
samples_count = last_sample - first_sample;
return buffer.size - samples_count - 1;
}
size_t OggFile::GetBufferSamplesCount() {
std::unique_lock<std::mutex> u_lock(mtx);
size_t last_sample = buffer.last_sample;
size_t first_sample = buffer.first_sample;
if (last_sample < first_sample)
return buffer.size - first_sample + last_sample;
else
return last_sample - first_sample;
}
int32_t OggFile::GetChannelPairsCount() {
std::unique_lock<std::mutex> u_lock(file_mtx);
if (info)
return (info->channels + 1) / 2;
return 0;
}
double_t OggFile::GetDuration() {
std::unique_lock<std::mutex> u_lock(file_mtx);
if (file)
return ov_time_total(file, -1);
return 0.0;
}
int32_t OggFile::GetRate() {
std::unique_lock<std::mutex> u_lock(file_mtx);
if (info)
return info->rate;
return 0;
}
bool OggFile::HasLoop() {
std::unique_lock<std::mutex> u_lock(file_mtx);
return loop_end >= 0;
}
bool OggFile::OpenFile(const char* path, double_t time_seek) {
{
std::unique_lock<std::mutex> u_lock(file_mtx);
if (file)
goto Reset;
file = force_malloc_s(OggVorbis_File, 1);
if (!file)
goto Reset;
if (ov_fopen(path, file) < 0)
goto Reset;
info = ov_info(file, -1);
comments = ov_comment(file, -1);
loop_begin = -1;
loop_end = -1;
if (!info || !comments) {
info = 0;
comments = 0;
goto Reset;
}
char** user_comments = comments->user_comments;
while (*user_comments) {
std::string user_comment = *user_comments++;
for (char& c : user_comment)
if (c > 0x40 && c < 0x5B)
c += 0x20;
if (user_comment.size() >= 10 && !memcmp(user_comment.c_str(), "loop_begin", 10)) {
const char* t = strchr(user_comment.c_str(), '=');
if (t) {
t++;
sscanf_s(t, "%lld", &loop_begin);
}
}
else if (user_comment.size() >= 8 && !memcmp(user_comment.c_str(), "loop_end", 8)) {
const char* t = strchr(user_comment.c_str(), '=');
if (t) {
t++;
sscanf_s(t, "%lld", &loop_end);
}
}
}
if (ov_time_seek(this->file, time_seek) >= 0)
return true;
}
Reset:
Reset();
return false;
}
void OggFile::Reset() {
std::unique_lock<std::mutex> u_lock(file_mtx);
if (file) {
ov_clear(file);
free(file);
}
buffer.Reset();
file = 0;
info = 0;
comments = 0;
loop_begin = -1;
loop_end = -1;
}
void OggFile::ThreadMain(OggFile* of) {
if (!of)
return;
waitable_timer timer;
while (!of->thread_state.get()) {
of->Ctrl(of->info ? of->info->rate : 44100);
timer.sleep(8);
}
of->thread_state.set(0);
}
OggFileHandler::OggFileHandler(size_t index) : time_seek(), channel_pairs_count(),
duration(), time(), channel_pairs_count_dup(), duration_dup(), time_dup(),
channel_pair_volume_pan(), master_volume(), channel_pair_volume(), req_time(), loop() {
this->index = index;
for (int32_t i = 0; i < 4; i++)
for (int32_t j = 0; j < 2; j++)
for (int32_t k = 0; k < 4; k++)
channel_pair_volume_pan[i][j][k] = -10000;
channel_pair_volume_pan[0][0][0] = 0;
channel_pair_volume_pan[0][1][1] = 0;
rate = 1;
thread = new std::thread(OggFileHandler::ThreadMain, this);
if (thread) {
wchar_t buf[0x80];
swprintf_s(buf, sizeof(buf) / sizeof(wchar_t), L"Ogg File Handler #%d", ogg_file_handler_counter++);
SetThreadDescription((HANDLE)thread->native_handle(), buf);
}
}
OggFileHandler::~OggFileHandler() {
Reset();
if (thread) {
thread_state.set(1);
thread->join();
delete thread;
thread = 0;
}
}
void OggFileHandler::Ctrl() {
int32_t _playback_state = 0;
{
std::unique_lock<std::mutex> u_lock(mtx);
_playback_state = playback_state.get();
playback_state.set(OGG_FILE_HANDLER_PLAYBACK_STATE_NONE);
switch (_playback_state) {
case OGG_FILE_HANDLER_PLAYBACK_STATE_PLAY:
Reset(false);
file_state.set(OGG_FILE_HANDLER_FILE_STATE_LOADING);
OpenFile();
file_state.set(OGG_FILE_HANDLER_FILE_STATE_READY);
req_time = 0.0;
ReadBufferProt(0, 0);
break;
case OGG_FILE_HANDLER_PLAYBACK_STATE_STOP:
Reset(true);
break;
}
}
sound::wasapi::System* sound_wasapi_system = sound_wasapi_system_data_get();
if (sound_wasapi_system) {
sound::wasapi::Mixer* mixer = sound_wasapi_system->mixer;
if (mixer) {
sound::wasapi::StreamingChannel* streaming_channel = mixer->GetStreamingChannel(index);
if (streaming_channel) {
switch (_playback_state) {
case OGG_FILE_HANDLER_PLAYBACK_STATE_PLAY:
if (sound_wasapi_system->pClockAdjustment)
sound_wasapi_system->pClockAdjustment->SetSampleRate((float_t)rate);
streaming_channel->SetMasterVolume(1.0f);
streaming_channel->SetCallback(OggFileHandler::FillBufferStatic, this);
break;
case OGG_FILE_HANDLER_PLAYBACK_STATE_STOP:
streaming_channel->reset_state.set(1);
break;
}
}
}
}
int32_t _channel_pairs_count = 0;
double_t _duration = 0.0;
double_t _time = 0.0;
{
std::unique_lock<std::mutex> u_lock(file_mtx);
_channel_pairs_count = channel_pairs_count;
_duration = duration;
_time = time;
}
{
std::unique_lock<std::mutex> u_lock(dup_mtx);
channel_pairs_count_dup = _channel_pairs_count;
duration_dup = _duration;
time_dup = _time;
}
int32_t value = ratio_to_db(1.0);
if (!_channel_pairs_count)
_channel_pairs_count = 2;
if (_channel_pairs_count >= 3 && _channel_pairs_count <= 4) {
for (int32_t i = 0; i < 2; i++) {
SetChannelPairVolumePan(i, 0, 0, value);
SetChannelPairVolumePan(i, 1, 1, value);
SetChannelPairVolumePan(i, 0, 2, -10000);
SetChannelPairVolumePan(i, 1, 3, -10000);
}
for (int32_t i = _channel_pairs_count - 2; i < _channel_pairs_count; i++) {
SetChannelPairVolumePan(i, 0, 0, -10000);
SetChannelPairVolumePan(i, 1, 1, -10000);
SetChannelPairVolumePan(i, 0, 2, value);
SetChannelPairVolumePan(i, 1, 3, value);
}
}
else
for (int32_t i = 0; i < _channel_pairs_count; i++) {
SetChannelPairVolumePan(i, 0, 0, value);
SetChannelPairVolumePan(i, 1, 1, value);
SetChannelPairVolumePan(i, 0, 2, value);
SetChannelPairVolumePan(i, 1, 3, value);
}
}
void OggFileHandler::FillBuffer(sound_buffer_data* buffer, size_t samples_count) {
int32_t _file_state = file_state.get();
file_state.set(OGG_FILE_HANDLER_FILE_STATE_NONE);
int32_t _playback_state = playback_state.get();
playback_state.set(0);
if (_file_state == OGG_FILE_HANDLER_FILE_STATE_PLAYING
&& _playback_state != OGG_FILE_HANDLER_PLAYBACK_STATE_STOP) {
std::unique_lock<std::mutex> u_lock(mtx);
ReadBufferProt(buffer, samples_count);
}
}
void OggFileHandler::OpenFile() {
std::unique_lock<std::mutex> u_lock(file_mtx);
if (file.OpenFile(path.c_str(), time_seek)) {
channel_pairs_count = file.GetChannelPairsCount();
duration = file.GetDuration();
time = 0.0;
rate = file.GetRate();
loop = file.HasLoop();
}
}
void OggFileHandler::ReadBuffer(sound_buffer_data* buffer, size_t samples_count) {
if (!samples_count)
return;
vec4 channel_pair_volume_pan[4][2];
float_t channel_pair_volume[4];
{
std::unique_lock<std::mutex> u_lock(volume_mtx);
float_t master_volume = db_to_ratio(this->master_volume);
for (int32_t i = 0; i < 4; i++) {
for (int32_t j = 0; j < 2; j++)
for (int32_t k = 0; k < 4; k++)
((float_t*)&channel_pair_volume_pan[i][j])[k]
= db_to_ratio(this->channel_pair_volume_pan[i][j][k]);
channel_pair_volume[i] = db_to_ratio(this->channel_pair_volume[i]) * master_volume;
}
}
size_t samples_count_in_buffer = file.GetBufferSamplesCount();
if (samples_count > samples_count_in_buffer) {
file.Ctrl(samples_count - samples_count_in_buffer);
file.GetBufferSamplesCount();
}
buffer_data.resize(samples_count);
if (!buffer_data.size())
return;
OggFileBufferData* _buffer_data = buffer_data.data();
size_t _samples_count = file.FillBufferData(_buffer_data, samples_count);
if (_samples_count)
req_time = _buffer_data->time;
else {
double_t _samples_count = (double_t)(int32_t)samples_count;
if (samples_count < 0)
_samples_count += 1.844674407370955e19;
req_time += _samples_count / (double_t)rate;
}
if (_samples_count) {
for (size_t i = _samples_count; i; i--, buffer++, _buffer_data++) {
OggFileBufferChannelData* channel_pair = _buffer_data->channel_pair;
vec4 value = vec4_null;
for (size_t j = 0; j < 4; j++, channel_pair++) {
value += (channel_pair_volume_pan[j][0] * (channel_pair_volume[j] * channel_pair->left));
value += (channel_pair_volume_pan[j][1] * (channel_pair_volume[j] * channel_pair->right));
}
*(vec4*)buffer = value;
}
}
else
memset(buffer, 0, sizeof(sound_buffer_data) * samples_count);
}
void OggFileHandler::ReadBufferProt(sound_buffer_data* buffer, size_t samples_count) {
file_state.set(OGG_FILE_HANDLER_FILE_STATE_PLAYING);
if (pause_state.get() != OGG_FILE_HANDLER_PAUSE_STATE_PLAY)
samples_count = 0;
bool process = false;
{
std::unique_lock<std::mutex> u_lock(file_mtx);
time = req_time;
process = req_time < duration;
}
if (process || loop)
ReadBuffer(buffer, samples_count);
else
playback_state.set(OGG_FILE_HANDLER_PLAYBACK_STATE_STOP);
}
void OggFileHandler::Reset(bool reset) {
if (reset) {
SetFileState(OGG_FILE_HANDLER_FILE_STATE_STOPPING);
std::unique_lock<std::mutex> u_lock(file_mtx);
channel_pairs_count = 0;
duration = 0.0;
time = 0.0;
}
file.Reset();
if (reset) {
SetFileState(OGG_FILE_HANDLER_FILE_STATE_STOPPED);
SetFileState(OGG_FILE_HANDLER_FILE_STATE_NONE);
}
}
void OggFileHandler::SetChannelPairVolumePan(size_t src_channel_pair,
int32_t src_channel, int32_t dst_channel, int32_t value) {
if (src_channel_pair < 0 || src_channel_pair >= 4 || src_channel < 0
|| src_channel >= 2 || dst_channel < 0 || dst_channel >= 4)
return;
value = clamp_def(value, -10000, 0);
std::unique_lock<std::mutex> u_lock(volume_mtx);
channel_pair_volume_pan[src_channel_pair][src_channel][dst_channel] = value;
}
void OggFileHandler::SetFileState(OggFileHandlerFileState state) {
file_state.set(state);
if (state == OGG_FILE_HANDLER_PLAYBACK_STATE_MAX)
Reset(false);
}
void OggFileHandler::SetPath(std::string& path) {
std::unique_lock<std::mutex> u_lock(mtx);
file_state.set(1);
playback_state.set(OGG_FILE_HANDLER_PLAYBACK_STATE_PLAY);
{
std::unique_lock<std::mutex> u_lock(file_mtx);
this->path.assign(path);
channel_pairs_count = 0;
duration = 0.0;
time = 0.0;
}
}
void OggFileHandler::SetPath(std::string&& path) {
SetPath(*(std::string*)&path);
}
void OggFileHandler::FillBufferStatic(sound_buffer_data* buffer, size_t samples_count, void* data) {
if (data)
((OggFileHandler*)data)->FillBuffer(buffer, samples_count);
}
bool OggFileHandler::LoadFile(void* data, const char* path, const char* file, uint32_t hash) {
OggFileHandler* ofh = (OggFileHandler*)data;
ofh->SetPath(std::string(path) + file);
return true;
}
void OggFileHandler::ThreadMain(OggFileHandler* ofh) {
if (!ofh)
return;
waitable_timer timer;
while (!ofh->thread_state.get()) {
ofh->Ctrl();
timer.sleep(8);
}
ofh->playback_state.set(OGG_FILE_HANDLER_PLAYBACK_STATE_STOP);
ofh->Ctrl();
ofh->thread_state.set(0);
}
src/CRE/ogg_vorbis.hpp
+150
View File
@@ -0,0 +1,150 @@
/*
by korenkonder
GitHub/GitLab: korenkonder
*/
#pragma once
#include "../KKdLib/default.hpp"
#include "../CRE/waitable_timer.hpp"
#include "lock.hpp"
#include "sound.hpp"
#include <mutex>
#include <thread>
#include <string>
#include <vector>
#include <vorbis/codec.h>
#include <vorbis/vorbisfile.h>
enum AudioBitFormat {
AUDIO_BIT_FORMAT_S16 = 0,
AUDIO_BIT_FORMAT_S24,
AUDIO_BIT_FORMAT_S32,
AUDIO_BIT_FORMAT_F32,
};
enum OggFileHandlerFileState {
OGG_FILE_HANDLER_FILE_STATE_NONE = 0,
OGG_FILE_HANDLER_FILE_STATE_LOADING,
OGG_FILE_HANDLER_FILE_STATE_READY,
OGG_FILE_HANDLER_FILE_STATE_PLAYING,
OGG_FILE_HANDLER_FILE_STATE_STOPPING,
OGG_FILE_HANDLER_FILE_STATE_STOPPED,
OGG_FILE_HANDLER_FILE_STATE_MAX,
};
enum OggFileHandlerPauseState {
OGG_FILE_HANDLER_PAUSE_STATE_PLAY = 0,
OGG_FILE_HANDLER_PAUSE_STATE_PAUSE,
OGG_FILE_HANDLER_PAUSE_STATE_MAX,
};
enum OggFileHandlerPlaybackState {
OGG_FILE_HANDLER_PLAYBACK_STATE_NONE = 0,
OGG_FILE_HANDLER_PLAYBACK_STATE_PLAY,
OGG_FILE_HANDLER_PLAYBACK_STATE_STOP,
OGG_FILE_HANDLER_PLAYBACK_STATE_MAX,
};
struct OggFileBufferChannelData {
float_t left;
float_t right;
OggFileBufferChannelData();
};
struct OggFileBufferData {
double_t time;
OggFileBufferChannelData channel_pair[4];
OggFileBufferData();
};
struct OggFileBuffer {
size_t size;
std::vector<OggFileBufferData> data;
size_t first_sample;
size_t last_sample;
OggFileBuffer();
~OggFileBuffer();
void Reset();
};
struct OggFile {
std::mutex mtx;
lock_uint32_t thread_state;
std::thread* thread;
OggFileBuffer buffer;
OggVorbis_File* file;
vorbis_info* info;
vorbis_comment* comments;
int64_t loop_begin;
int64_t loop_end;
std::mutex file_mtx;
OggFile();
virtual ~OggFile();
void Ctrl(size_t samples_count);
size_t FillBufferData(OggFileBufferData* buffer_data, size_t samples_count);
size_t GetBufferFreeSamplesCount();
size_t GetBufferSamplesCount();
int32_t GetChannelPairsCount();
double_t GetDuration();
int32_t GetRate();
bool HasLoop();
bool OpenFile(const char* path, double_t time_seek);
void Reset();
static void ThreadMain(OggFile* of);
};
struct OggFileHandler {
std::mutex mtx;
lock_uint32_t thread_state;
std::thread* thread;
size_t index;
OggFile file;
std::mutex file_mtx;
std::string path;
float_t time_seek;
int32_t channel_pairs_count;
double_t duration;
double_t time;
std::mutex dup_mtx;
int32_t channel_pairs_count_dup;
double_t duration_dup;
double_t time_dup;
std::mutex volume_mtx;
int32_t channel_pair_volume_pan[4][2][4];
int32_t master_volume;
int32_t channel_pair_volume[4];
lock_uint32_t file_state;
lock_uint32_t playback_state;
lock_uint32_t pause_state;
double_t req_time;
int32_t rate;
bool loop;
std::vector<OggFileBufferData> buffer_data;
OggFileHandler(size_t index = 0);
virtual ~OggFileHandler();
void Ctrl();
void FillBuffer(sound_buffer_data* buffer, size_t samples_count);
void OpenFile();
void ReadBuffer(sound_buffer_data* buffer, size_t samples_count);
void ReadBufferProt(sound_buffer_data* buffer, size_t samples_count);
void Reset(bool reset = false);
void SetChannelPairVolumePan(size_t src_channel_pair,
int32_t src_channel, int32_t dst_channel, int32_t value);
void SetFileState(OggFileHandlerFileState state);
void SetPath(std::string& path);
void SetPath(std::string&& path);
static void FillBufferStatic(sound_buffer_data* buffer, size_t samples_count, void* data);
static bool LoadFile(void* data, const char* path, const char* file, uint32_t hash);
static void ThreadMain(OggFileHandler* ofh);
};
src/CRE/post_process.cpp
+17 -25
View File
@@ -15,7 +15,7 @@
extern bool task_stage_is_modern;
post_process::post_process() : ssaa(), mlaa(), parent_bone_node(), render_textures_data(),
post_process::post_process() : ssaa(), mlaa(), ss_alpha_mask(), render_textures_data(),
movie_textures_data(), lens_flare_texture(), lens_shaft_texture(), lens_ghost_texture(),
lens_flare_count(), lens_flare_pos(), lens_shaft_scale(), lens_shaft_inv_scale(),
lens_flare_power(), field_A10(), lens_flare_appear_power(), render_width(), render_height(),
@@ -39,7 +39,7 @@ sprite_height(), screen_x_offset(), screen_y_offset(), screen_width(), screen_he
"layout(location = 0) out vec4 result;\n"
"\n"
"void main() {\n"
" result = vec4(0.0); \n"
" result = vec4(0.0);\n"
"}\n";
static const char* alpha_layer_vert_shader =
@@ -86,12 +86,12 @@ sprite_height(), screen_x_offset(), screen_y_offset(), screen_width(), screen_he
glGenSamplers(2, samplers);
glSamplerParameteri(samplers[0], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glSamplerParameteri(samplers[0], GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glSamplerParameteri(samplers[0], GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glSamplerParameteri(samplers[0], GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glSamplerParameteri(samplers[0], GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glSamplerParameteri(samplers[0], GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glSamplerParameteri(samplers[1], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glSamplerParameteri(samplers[1], GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glSamplerParameteri(samplers[1], GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glSamplerParameteri(samplers[1], GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glSamplerParameteri(samplers[1], GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glSamplerParameteri(samplers[1], GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
const float_t verts_quad[] = {
-1.0f, 1.0f, 0.15f, 0.85f,
@@ -192,7 +192,7 @@ void post_process::apply(camera* cam, texture* light_proj_tex, int32_t npr_param
blur->tex[0].color_texture->tex,
exposure->exposure.color_texture->tex, npr_param);
if (mlaa)
aa->apply_mlaa(&rend_texture, &buf_texture, samplers, parent_bone_node);
aa->apply_mlaa(&rend_texture, &buf_texture, samplers, ss_alpha_mask);
for (int32_t i = 0; i < 16; i++) {
if (!render_textures_data[i])
@@ -223,12 +223,12 @@ void post_process::apply(camera* cam, texture* light_proj_tex, int32_t npr_param
if (ssaa) {
gl_state_active_bind_texture_2d(0, rend_texture.color_texture->tex);
gl_state_bind_sampler(0, samplers[0]);
uniform_value[U01] = parent_bone_node ? 1 : 0;
uniform_value[U_ALPHA_MASK] = ss_alpha_mask ? 1 : 0;
uniform_value[U_REDUCE] = 0;
shaders_ft.set(SHADER_FT_REDUCE);
render_texture::draw_params(&shaders_ft, render_width,
render_height, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
uniform_value[U01] = 0;
uniform_value[U_ALPHA_MASK] = 0;
}
else {
gl_state_active_bind_texture_2d(0, rend_texture.color_texture->tex);
@@ -279,19 +279,12 @@ void post_process::ctrl(camera* cam) {
reset_exposure = cam->fast_change_hist1 && !cam->fast_change_hist0;
if (reset_exposure) {
float_t view_point_dist;
vec3_distance(view_point, view_point_prev, view_point_dist);
float_t view_point_dist = vec3::distance(view_point, view_point_prev);
vec3 dir;
vec3_sub(interest, view_point, dir);
vec3_normalize(dir, dir);
vec3 dir = vec3::normalize(interest - view_point);
vec3 dir_prev = vec3::normalize(interest_prev - view_point_prev);
vec3 dir_prev;
vec3_sub(interest_prev, view_point_prev, dir_prev);
vec3_normalize(dir_prev, dir_prev);
float_t dir_diff_angle;
vec3_dot(dir, dir_prev, dir_diff_angle);
float_t dir_diff_angle = vec3::dot(dir, dir_prev);
if (dir_diff_angle < 0.5f)
dir_diff_angle = 0.0f;
if (view_point_dist < dir_diff_angle * 0.4f)
@@ -310,7 +303,6 @@ void post_process::draw_query_samples(GLuint query, float_t scale, mat4& mat) {
gl_state_bind_vertex_array(0);
glEndQuery(GL_SAMPLES_PASSED);
}
void post_process::init_fbo(int32_t render_width, int32_t render_height,
int32_t sprite_width, int32_t sprite_height, int32_t screen_width, int32_t screen_height) {
if (this->render_width == render_width && this->render_height == render_height
@@ -323,12 +315,12 @@ void post_process::init_fbo(int32_t render_width, int32_t render_height,
dof->init_fbo(render_width, render_height);
exposure->init_fbo();
tone_map->init_fbo();
rend_texture.init(render_width, render_height, 0, GL_RGBA16F, GL_DEPTH24_STENCIL8);
rend_texture.init(render_width, render_height, 0, GL_RGBA16F, GL_DEPTH_COMPONENT32F);
buf_texture.init(render_width, render_height, 0, GL_RGBA16F, 0);
sss_contour_texture.init(render_width, render_height, 0, GL_RGBA16F, GL_DEPTH24_STENCIL8);
sss_contour_texture.init(render_width, render_height, 0, GL_RGBA16F, GL_DEPTH_COMPONENT32F);
pre_texture.init(render_width, render_height, 0, GL_RGBA16F, 0);
post_texture.init(render_width, render_height, 0, GL_RGBA16F, 0);
alpha_layer_texture.init(render_width, render_height, 0, GL_RGBA16F, GL_DEPTH24_STENCIL8);
alpha_layer_texture.init(render_width, render_height, 0, GL_RGBA16F, GL_DEPTH_COMPONENT32F);
gl_state_bind_texture_2d(rend_texture.depth_texture->tex);
GLint swizzle[] = { GL_RED, GL_RED, GL_RED, GL_ONE };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle);
@@ -347,7 +339,7 @@ void post_process::init_fbo(int32_t render_width, int32_t render_height,
if (this->screen_width != screen_width || this->screen_height != screen_height) {
fbo_texture.init(screen_width, screen_height, 0, GL_RGBA16F, 0);
screen_texture.init(screen_width, screen_height, 0, GL_R11F_G11F_B10F, 0);
screen_texture.init(screen_width, screen_height, 0, GL_RGBA16F, 0); // Was GL_R11F_G11F_B10F
this->screen_width = screen_width;
this->screen_height = screen_height;
}
src/CRE/post_process.hpp
+1 -1
View File
@@ -27,7 +27,7 @@ enum post_process_mag_filter_type {
struct post_process {
bool ssaa;
bool mlaa;
int32_t parent_bone_node;
int32_t ss_alpha_mask;
render_texture rend_texture;
render_texture buf_texture;
render_texture sss_contour_texture;
src/CRE/post_process/aa.cpp
+19 -13
View File
@@ -36,12 +36,14 @@ post_process_aa::~post_process_aa() {
}
void post_process_aa::apply_mlaa(render_texture* rt,
render_texture* buf_rt, GLuint* samplers, int32_t a4) {
render_texture* buf_rt, GLuint* samplers, int32_t ss_alpha_mask) {
mlaa_buffer->bind();
gl_state_active_bind_texture_2d(0, rt->color_texture->tex);
gl_state_bind_sampler(0, samplers[1]);
uniform_value[U_MLAA] = 0;
shaders_ft.set(SHADER_FT_MLAA);
//uniform_value[U_MLAA] = 0;
//shaders_ft.set(SHADER_FT_MLAA);
uniform_value[U_ALPHA_MASK] = 0;
shaders_ft.set(SHADER_FT_MLAA_EDGE);
render_texture::draw_params(&shaders_ft, width, height, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
mlaa_buffer[1].bind();
@@ -49,20 +51,24 @@ void post_process_aa::apply_mlaa(render_texture* rt,
gl_state_active_bind_texture_2d(1, mlaa_area_texture);
gl_state_bind_sampler(0, samplers[0]);
gl_state_bind_sampler(1, samplers[1]);
uniform_value[U20] = 2;
uniform_value[U_MLAA] = 1;
shaders_ft.set(SHADER_FT_MLAA);
//uniform_value[U_MLAA_SEARCH] = 2;
//uniform_value[U_MLAA] = 1;
//shaders_ft.set(SHADER_FT_MLAA);
uniform_value[U_MLAA_SEARCH] = 2;
shaders_ft.set(SHADER_FT_MLAA_AREA);
render_texture::draw_params(&shaders_ft, width, height, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
buf_rt->bind();
gl_state_active_bind_texture_2d(0, rt->color_texture->tex);
gl_state_active_bind_texture_2d(1, mlaa_buffer[1].color_texture->tex);
gl_state_bind_sampler(0, samplers[1]);
uniform_value[U_MLAA] = 2;
uniform_value[U01] = a4 ? 1 : 0;
shaders_ft.set(SHADER_FT_MLAA);
//uniform_value[U_MLAA] = 2;
//uniform_value[U_ALPHA_MASK] = ss_alpha_mask ? 1 : 0;
//shaders_ft.set(SHADER_FT_MLAA);
uniform_value[U_ALPHA_MASK] = ss_alpha_mask ? 1 : 0;
shaders_ft.set(SHADER_FT_MLAA_BLEND);
render_texture::draw_params(&shaders_ft, width, height, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
uniform_value[U01] = 0;
uniform_value[U_ALPHA_MASK] = 0;
gl_state_active_bind_texture_2d(0, 0);
gl_state_active_bind_texture_2d(1, 0);
@@ -75,8 +81,8 @@ void post_process_aa::init_fbo(int32_t width, int32_t height) {
if (!this || (this->width == width && this->height == height))
return;
this->width = max(width, 1);
this->height = max(height, 1);
this->width = max_def(width, 1);
this->height = max_def(height, 1);
mlaa_buffer[0].init(this->width, this->height, 0, GL_RGBA8, 0);
mlaa_buffer[1].init(this->width, this->height, 0, GL_RGBA8, 0);
@@ -101,7 +107,7 @@ static void post_process_aa_calculate_area_texture_data_sub(float_t* a2,
float_t v8 = 0.0f;
float_t v10 = 0.0f;
int32_t v11 = a6 + a7 + 1;
v11 = min(v11, 7);
v11 = min_def(v11, 7);
int32_t v12;
if (((a6 + a7 + 1) & 1) != 0)
src/CRE/post_process/aa.hpp
+1 -1
View File
@@ -20,6 +20,6 @@ struct post_process_aa {
virtual ~post_process_aa();
void apply_mlaa(render_texture* rt,
render_texture* buf_rt, GLuint* samplers, int32_t a4);
render_texture* buf_rt, GLuint* samplers, int32_t ss_alpha_mask);
void init_fbo(int32_t width, int32_t height);
};
src/CRE/post_process/blur.cpp
+20 -20
View File
@@ -29,13 +29,13 @@ post_process_blur:: ~post_process_blur() {
for (int32_t i = 0; i < count_down; i++)
tex_down[i].free_data();
free(tex_down);
free(height_down);
free(width_down);
free_def(tex_down);
free_def(height_down);
free_def(width_down);
}
void post_process_blur::get_blur(render_texture* rt) {
uniform_value[U01] = 0;
uniform_value[U_ALPHA_MASK] = 0;
int32_t i = 0;
if (count_down > 0) {
@@ -110,7 +110,7 @@ void post_process_blur::get_blur(render_texture* rt) {
vec3 v[POST_PROCESS_BLUR_GAUSSIAN_KERNEL_SIZE];
for (int32_t i = 0; i < POST_PROCESS_BLUR_GAUSSIAN_KERNEL_SIZE; i++)
vec3_mult(gauss[i], intensity, v[i]);
v[i] = gauss[i] * intensity;
uniform_value[U_GAUSS] = 0;
render_texture::shader_set(&shaders_ft, SHADER_FT_GAUSS);
@@ -205,7 +205,7 @@ void post_process_blur::init_fbo(int32_t width, int32_t height) {
else if (count_down < i) {
render_texture* temp = force_malloc_s(render_texture, i);
memcpy(temp, tex_down, sizeof(render_texture) * count_down);
free(tex_down);
free_def(tex_down);
tex_down = temp;
}
@@ -214,7 +214,7 @@ void post_process_blur::init_fbo(int32_t width, int32_t height) {
else if (count_down < i) {
int32_t* temp = force_malloc_s(int32_t, i);
memcpy(temp, width_down, sizeof(int32_t) * count_down);
free(width_down);
free_def(width_down);
width_down = temp;
}
@@ -223,7 +223,7 @@ void post_process_blur::init_fbo(int32_t width, int32_t height) {
else if (count_down < i) {
int32_t* temp = force_malloc_s(int32_t, i);
memcpy(temp, height_down, sizeof(int32_t) * count_down);
free(height_down);
free_def(height_down);
height_down = temp;
}
@@ -249,12 +249,12 @@ void post_process_blur::init_fbo(int32_t width, int32_t height) {
}
void post_process_blur::initialize_data(const vec3& radius, const vec3& intensity) {
data.radius.x = clamp(radius.x, 1.0f, 3.0f);
data.radius.y = clamp(radius.y, 1.0f, 3.0f);
data.radius.z = clamp(radius.z, 1.0f, 3.0f);
data.intensity.x = clamp(intensity.x, 0.0f, 2.0f);
data.intensity.y = clamp(intensity.y, 0.0f, 2.0f);
data.intensity.z = clamp(intensity.z, 0.0f, 2.0f);
data.radius.x = clamp_def(radius.x, 1.0f, 3.0f);
data.radius.y = clamp_def(radius.y, 1.0f, 3.0f);
data.radius.z = clamp_def(radius.z, 1.0f, 3.0f);
data.intensity.x = clamp_def(intensity.x, 0.0f, 2.0f);
data.intensity.y = clamp_def(intensity.y, 0.0f, 2.0f);
data.intensity.z = clamp_def(intensity.z, 0.0f, 2.0f);
post_process_blur_radius_calculate(this);
}
@@ -263,9 +263,9 @@ vec3 post_process_blur::get_intensity() {
}
void post_process_blur::set_intensity(const vec3& value) {
data.intensity.x = clamp(value.x, 0.0f, 2.0f);
data.intensity.y = clamp(value.y, 0.0f, 2.0f);
data.intensity.z = clamp(value.z, 0.0f, 2.0f);
data.intensity.x = clamp_def(value.x, 0.0f, 2.0f);
data.intensity.y = clamp_def(value.y, 0.0f, 2.0f);
data.intensity.z = clamp_def(value.z, 0.0f, 2.0f);
}
vec3 post_process_blur::get_radius() {
@@ -274,9 +274,9 @@ vec3 post_process_blur::get_radius() {
void post_process_blur::set_radius(const vec3& value) {
vec3 temp;
temp.x = clamp(value.x, 1.0f, 3.0f);
temp.y = clamp(value.y, 1.0f, 3.0f);
temp.z = clamp(value.z, 1.0f, 3.0f);
temp.x = clamp_def(value.x, 1.0f, 3.0f);
temp.y = clamp_def(value.y, 1.0f, 3.0f);
temp.z = clamp_def(value.z, 1.0f, 3.0f);
if (memcmp(&temp, &data.radius, sizeof(vec3))) {
data.radius = temp;
post_process_blur_radius_calculate(this);
src/CRE/post_process/dof.cpp
+30 -27
View File
@@ -566,8 +566,14 @@ static const char* dof_frag_shader_upsample =
" is thinly combined with the actual resolution because it's not good\n"
" combined_factor = clamp(combined_factor, 0.0, 1.0);\n"
"#endif\n"
"#if 1\n"
" // Fix alpha\n"
" result.rgb = max(tone_map(mix(half_res.rgb, full_res.rgb, combined_factor), 1.0), vec3(0.0));\n"
" result.a = full_res.a;\n"
"#else\n"
" result = mix(half_res, full_res, combined_factor);\n"
" result.rgb = max(tone_map(result.rgb, 1.0), vec3(0.0));\n"
"#endif\n"
"}\n";
static const dof_debug dof_debug_default = {
@@ -668,20 +674,20 @@ void post_process_dof::apply(render_texture* rt, GLuint* samplers, camera* cam)
mat4 view_transpose;
mat4_transpose(&cam->view, &view_transpose);
vec3_dot(*(vec3*)&view_transpose.row2, chara_trans, focus);
focus = -focus - view_transpose.row2.w - 0.1f;
focus = -vec3::dot(*(vec3*)&view_transpose.row2, chara_trans)
- view_transpose.row2.w - 0.1f;
break;
}
}
focus = max(focus, (float_t)cam->min_distance);
focus = max_def(focus, (float_t)cam->min_distance);
renderer::DOF3::apply_physical(this, rt, samplers,
rt->color_texture->tex, rt->depth_texture->tex,
(float_t)cam->min_distance, (float_t)cam->max_distance, focus,
data.debug.focal_length, (float_t)cam->fov_rad, data.debug.f_number);
}
else {
float_t fuzzing_range = max(data.debug.f2.fuzzing_range, 0.01f);
float_t fuzzing_range = max_def(data.debug.f2.fuzzing_range, 0.01f);
renderer::DOF3::apply_f2(this, rt, samplers,
rt->color_texture->tex, rt->depth_texture->tex,
(float_t)cam->min_distance, (float_t)cam->max_distance, (float_t)cam->fov_rad,
@@ -691,7 +697,7 @@ void post_process_dof::apply(render_texture* rt, GLuint* samplers, camera* cam)
}
}
else if (data.pv.enable && data.pv.f2.ratio > 0.0f) {
float_t fuzzing_range = max(data.pv.f2.fuzzing_range, 0.01f);
float_t fuzzing_range = max_def(data.pv.f2.fuzzing_range, 0.01f);
renderer::DOF3::apply_f2(this, rt, samplers,
rt->color_texture->tex, rt->depth_texture->tex,
(float_t)cam->min_distance, (float_t)cam->max_distance, (float_t)cam->fov_rad,
@@ -725,10 +731,10 @@ void post_process_dof::init_fbo(int32_t width, int32_t height) {
this->width = width;
this->height = height;
int32_t w20 = max(width / 20, 1);
int32_t h20 = max(height / 20, 1);
int32_t w2 = max(width / 2, 1);
int32_t h2 = max(height / 2, 1);
int32_t w20 = max_def(width / 20, 1);
int32_t h20 = max_def(height / 20, 1);
int32_t w2 = max_def(width / 2, 1);
int32_t h2 = max_def(height / 2, 1);
glGenTextures(6, textures);
gl_state_bind_texture_2d(textures[0]);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RG16F, w20, h20);
@@ -828,10 +834,7 @@ static void post_process_dof_calculate_texcoords(vec2* data, float_t size) {
v8 *= size;
v11 = v9 * (float_t)(M_PI * 0.25);
vec2 t;
t.x = cosf(v11);
t.y = sinf(v11);
vec2_mult_scalar(t, v8, *data++);
*data++ = vec2(cosf(v11), sinf(v11)) * v8;
}
}
}
@@ -865,27 +868,27 @@ static void post_process_dof_load_shaders(post_process_dof* dof) {
t0 = str_utils_copy(dof_frag_shader_version);
t1 = str_utils_add(t0, shared);
frag_shader_string[1 + i * 4] = str_utils_add(t1, dof_frag_shader_render_tiles_part_1);
free(t0);
free(t1);
free_def(t0);
free_def(t1);
t0 = str_utils_copy(dof_frag_shader_version);
t1 = str_utils_add(t0, shared);
frag_shader_string[2 + i * 4] = str_utils_add(t1, dof_frag_shader_downsample);
free(t0);
free(t1);
free_def(t0);
free_def(t1);
t0 = str_utils_copy(dof_frag_shader_version);
t1 = str_utils_add(t0, shared);
frag_shader_string[3 + i * 4] = str_utils_add(t1, dof_frag_shader_apply_main_filter);
free(t0);
free(t1);
free_def(t0);
free_def(t1);
t0 = str_utils_copy(dof_frag_shader_version);
t1 = str_utils_add(t0, shared);
frag_shader_string[4 + i * 4] = str_utils_add(t1, dof_frag_shader_upsample);
free(t0);
free(t1);
free(shared);
free_def(t0);
free_def(t1);
free_def(shared);
}
GLuint vert_shader = post_process_dof_shader_compile(GL_VERTEX_SHADER, dof_vert_shader);
@@ -893,7 +896,7 @@ static void post_process_dof_load_shaders(post_process_dof* dof) {
GLuint frag_shader = post_process_dof_shader_compile(GL_FRAGMENT_SHADER, frag_shader_string[i]);
dof->program[i] = post_process_dof_program_link(vert_shader, frag_shader);
glDeleteShader(frag_shader);
free(frag_shader_string[i]);
free_def(frag_shader_string[i]);
}
glDeleteShader(vert_shader);
}
@@ -911,10 +914,10 @@ static GLuint post_process_dof_shader_compile(GLenum type, const char* data) {
if (!success) {
GLchar* info_log = force_malloc_s(GLchar, 0x10000);
glGetShaderInfoLog(shader, 0x10000, 0, info_log);
printf("Shader compile error: ");
printf("DOF Shader compile error: ");
printf(info_log);
putchar('\n');
free(info_log);
free_def(info_log);
}
return shader;
}
@@ -932,10 +935,10 @@ static GLuint post_process_dof_program_link(GLuint vert_shad, GLuint frag_shad)
if (!success) {
GLchar* info_log = force_malloc_s(GLchar, 0x10000);
glGetProgramInfoLog(program, 0x10000, 0, info_log);
printf("DOF Program Shader linking error:\n");
printf("DOF shader linking error:\n");
printf(info_log);
putchar('\n');
free(info_log);
free_def(info_log);
glDeleteProgram(program);
return 0;
}
src/CRE/post_process/exposure.cpp
+5 -6
View File
@@ -12,15 +12,14 @@
static void sub_1405163C0(rob_chara* rob_chr, int32_t a2, mat4* mat);
post_process_exposure_chara_data::post_process_exposure_chara_data() : field_80(), query(), query_data() {
for (GLuint& i : query_data)
i = -1;
}
post_process_exposure::post_process_exposure() : exposure_history_counter(),
chara_data(), query_index() {
chara_data = new post_process_exposure_chara_data[ROB_CHARA_COUNT];
for (int32_t i = 0; i < ROB_CHARA_COUNT; i++) {
memset(&chara_data[i], 0, sizeof(post_process_exposure_chara_data));
chara_data[i].query_data[0] = -1;
chara_data[i].query_data[1] = -1;
chara_data[i].query_data[2] = -1;
}
}
post_process_exposure::~post_process_exposure() {
src/CRE/post_process/exposure.hpp
+2
View File
@@ -16,6 +16,8 @@ struct post_process_exposure_chara_data {
float_t field_80;
GLuint query[3];
GLuint query_data[3];
post_process_exposure_chara_data();
};
struct post_process_exposure {
src/CRE/post_process/tone_map.cpp
+51 -48
View File
@@ -12,7 +12,13 @@
static void post_process_tone_map_calculate_data(post_process_tone_map* tm);
static void post_process_tone_map_calculate_tex(post_process_tone_map* tm);
post_process_tone_map::post_process_tone_map() : data(), shader_data(), tone_map() {
post_process_tone_map_data::post_process_tone_map_data() : tex(), exposure(), auto_exposure(), gamma(),
gamma_rate(), saturate_power(), saturate_coeff(), scene_fade_blend_func(), tone_map_method(), lens_flare(),
lens_shaft(), lens_ghost(), lens_flare_power(), lens_flare_appear_power(), update(), update_tex() {
}
post_process_tone_map::post_process_tone_map() : shader_data(), tone_map() {
}
@@ -130,24 +136,24 @@ void post_process_tone_map::initialize_data(float_t exposure, bool auto_exposure
float_t gamma, float_t gamma_rate, int32_t saturate_power, float_t saturate_coeff,
const vec3& scene_fade_color, float_t scene_fade_alpha, int32_t scene_fade_blend_func,
const vec3& tone_trans_start, const vec3& tone_trans_end, tone_map_method tone_map_method) {
data.exposure = clamp(exposure, 0.0f, 4.0f);
data.exposure = clamp_def(exposure, 0.0f, 4.0f);
data.auto_exposure = auto_exposure;
data.gamma = clamp(gamma, 0.2f, 2.2f);
data.gamma_rate = clamp(gamma_rate, 0.5f, 2.0f);
data.saturate_power = clamp(saturate_power, 1, 6);
data.saturate_coeff = clamp(saturate_coeff, 0.0f, 1.0f);
data.scene_fade.x = clamp(scene_fade_color.x, 0.0f, 1.0f);
data.scene_fade.y = clamp(scene_fade_color.y, 0.0f, 1.0f);
data.scene_fade.z = clamp(scene_fade_color.z, 0.0f, 1.0f);
data.scene_fade.w = clamp(scene_fade_alpha, 0.0f, 1.0f);
data.scene_fade_blend_func = clamp(scene_fade_blend_func, 0, 2);
data.tone_trans_start.x = clamp(tone_trans_start.x, 0.0f, 1.0f);
data.tone_trans_start.y = clamp(tone_trans_start.y, 0.0f, 1.0f);
data.tone_trans_start.z = clamp(tone_trans_start.z, 0.0f, 1.0f);
data.tone_trans_end.x = clamp(tone_trans_end.x, 0.0f, 1.0f);
data.tone_trans_end.y = clamp(tone_trans_end.y, 0.0f, 1.0f);
data.tone_trans_end.z = clamp(tone_trans_end.z, 0.0f, 1.0f);
data.tone_map_method = clamp(tone_map_method, TONE_MAP_YCC_EXPONENT, TONE_MAP_RGB_LINEAR2);
data.gamma = clamp_def(gamma, 0.2f, 2.2f);
data.gamma_rate = clamp_def(gamma_rate, 0.5f, 2.0f);
data.saturate_power = clamp_def(saturate_power, 1, 6);
data.saturate_coeff = clamp_def(saturate_coeff, 0.0f, 1.0f);
data.scene_fade.x = clamp_def(scene_fade_color.x, 0.0f, 1.0f);
data.scene_fade.y = clamp_def(scene_fade_color.y, 0.0f, 1.0f);
data.scene_fade.z = clamp_def(scene_fade_color.z, 0.0f, 1.0f);
data.scene_fade.w = clamp_def(scene_fade_alpha, 0.0f, 1.0f);
data.scene_fade_blend_func = clamp_def(scene_fade_blend_func, 0, 2);
data.tone_trans_start.x = clamp_def(tone_trans_start.x, 0.0f, 1.0f);
data.tone_trans_start.y = clamp_def(tone_trans_start.y, 0.0f, 1.0f);
data.tone_trans_start.z = clamp_def(tone_trans_start.z, 0.0f, 1.0f);
data.tone_trans_end.x = clamp_def(tone_trans_end.x, 0.0f, 1.0f);
data.tone_trans_end.y = clamp_def(tone_trans_end.y, 0.0f, 1.0f);
data.tone_trans_end.z = clamp_def(tone_trans_end.z, 0.0f, 1.0f);
data.tone_map_method = clamp_def(tone_map_method, TONE_MAP_YCC_EXPONENT, TONE_MAP_RGB_LINEAR2);
data.update_tex = false;
data.update = true;
data.update_tex = true;
@@ -170,7 +176,7 @@ float_t post_process_tone_map::get_exposure() {
}
void post_process_tone_map::set_exposure(float_t value) {
value = clamp(value, 0.0f, 4.0f);
value = clamp_def(value, 0.0f, 4.0f);
if (value != data.exposure) {
data.exposure = value;
data.update = true;
@@ -183,7 +189,7 @@ float_t post_process_tone_map::get_gamma() {
}
void post_process_tone_map::set_gamma(float_t value) {
value = clamp(value, 0.2f, 2.2f);
value = clamp_def(value, 0.2f, 2.2f);
if (value != data.gamma) {
data.gamma = value;
data.update = true;
@@ -196,7 +202,7 @@ float_t post_process_tone_map::get_gamma_rate() {
}
void post_process_tone_map::set_gamma_rate(float_t value) {
value = clamp(value, 0.5f, 2.0f);
value = clamp_def(value, 0.5f, 2.0f);
if (value != data.gamma_rate) {
data.gamma_rate = value;
data.update_tex = true;
@@ -208,7 +214,7 @@ float_t post_process_tone_map::get_lens_flare() {
}
void post_process_tone_map::set_lens_flare(float_t value) {
value = clamp(value, 0.0f, 1.0f);
value = clamp_def(value, 0.0f, 1.0f);
if (value != data.lens_flare) {
data.lens_flare = value;
data.update = true;
@@ -220,7 +226,7 @@ float_t post_process_tone_map::get_lens_ghost() {
}
void post_process_tone_map::set_lens_ghost(float_t value) {
data.lens_ghost = clamp(value, 0.0f, 1.0f);
data.lens_ghost = clamp_def(value, 0.0f, 1.0f);
}
float_t post_process_tone_map::get_lens_shaft() {
@@ -228,7 +234,7 @@ float_t post_process_tone_map::get_lens_shaft() {
}
void post_process_tone_map::set_lens_shaft(float_t value) {
value = clamp(value, 0.0f, 1.0f);
value = clamp_def(value, 0.0f, 1.0f);
if (value != data.lens_shaft) {
data.lens_shaft = value;
data.update = true;
@@ -240,7 +246,7 @@ float_t post_process_tone_map::get_saturate_coeff() {
}
void post_process_tone_map::set_saturate_coeff(float_t value) {
value = clamp(value, 0.0f, 1.0f);
value = clamp_def(value, 0.0f, 1.0f);
if (value != data.saturate_coeff) {
data.saturate_coeff = value;
data.update_tex = true;
@@ -252,7 +258,7 @@ int32_t post_process_tone_map::get_saturate_power() {
}
void post_process_tone_map::set_saturate_power(int32_t value) {
value = clamp(value, 1, 6);
value = clamp_def(value, 1, 6);
if (value != data.saturate_power) {
data.saturate_power = value;
data.update_tex = true;
@@ -265,10 +271,10 @@ vec4 post_process_tone_map::get_scene_fade() {
void post_process_tone_map::set_scene_fade(const vec4& value) {
vec4 temp;
temp.x = clamp(value.x, 0.0f, 1.0f);
temp.y = clamp(value.y, 0.0f, 1.0f);
temp.z = clamp(value.z, 0.0f, 1.0f);
temp.z = clamp(value.w, 0.0f, 1.0f);
temp.x = clamp_def(value.x, 0.0f, 1.0f);
temp.y = clamp_def(value.y, 0.0f, 1.0f);
temp.z = clamp_def(value.z, 0.0f, 1.0f);
temp.z = clamp_def(value.w, 0.0f, 1.0f);
if (memcmp(&temp, &data.scene_fade, sizeof(vec4))) {
data.scene_fade = temp;
data.update = true;
@@ -280,7 +286,7 @@ float_t post_process_tone_map::get_scene_fade_alpha() {
}
void post_process_tone_map::set_scene_fade_alpha(float_t value) {
value = clamp(value, 0.0f, 1.0f);
value = clamp_def(value, 0.0f, 1.0f);
if (value != data.scene_fade.w) {
data.scene_fade.w = value;
data.update = true;
@@ -292,7 +298,7 @@ int32_t post_process_tone_map::get_scene_fade_blend_func() {
}
void post_process_tone_map::set_scene_fade_blend_func(int32_t value) {
value = clamp(value, 0, 2);
value = clamp_def(value, 0, 2);
if (value != data.scene_fade_blend_func) {
data.scene_fade_blend_func = value;
data.update = true;
@@ -305,9 +311,9 @@ vec3 post_process_tone_map::get_scene_fade_color() {
void post_process_tone_map::set_scene_fade_color(const vec3& value) {
vec3 temp;
temp.x = clamp(value.x, 0.0f, 1.0f);
temp.y = clamp(value.y, 0.0f, 1.0f);
temp.z = clamp(value.z, 0.0f, 1.0f);
temp.x = clamp_def(value.x, 0.0f, 1.0f);
temp.y = clamp_def(value.y, 0.0f, 1.0f);
temp.z = clamp_def(value.z, 0.0f, 1.0f);
if (memcmp(&temp, &data.scene_fade, sizeof(vec3))) {
*(vec3*)&data.scene_fade = temp;
data.update = true;
@@ -319,7 +325,7 @@ tone_map_method post_process_tone_map::get_tone_map_method() {
}
void post_process_tone_map::set_tone_map_method(tone_map_method value) {
value = clamp(value, TONE_MAP_YCC_EXPONENT, TONE_MAP_RGB_LINEAR2);
value = clamp_def(value, TONE_MAP_YCC_EXPONENT, TONE_MAP_RGB_LINEAR2);
if (value != data.tone_map_method) {
data.tone_map_method = value;
data.update = true;
@@ -342,9 +348,9 @@ vec3 post_process_tone_map::get_tone_trans_end() {
void post_process_tone_map::set_tone_trans_end(const vec3& value) {
vec3 temp;
temp.x = clamp(value.x, 0.0f, 1.0f);
temp.y = clamp(value.y, 0.0f, 1.0f);
temp.z = clamp(value.z, 0.0f, 1.0f);
temp.x = clamp_def(value.x, 0.0f, 1.0f);
temp.y = clamp_def(value.y, 0.0f, 1.0f);
temp.z = clamp_def(value.z, 0.0f, 1.0f);
if (memcmp(&temp, &data.tone_trans_end, sizeof(vec3))) {
data.tone_trans_end = temp;
data.update = true;
@@ -357,9 +363,9 @@ vec3 post_process_tone_map::get_tone_trans_start() {
void post_process_tone_map::set_tone_trans_start(const vec3& value) {
vec3 temp;
temp.x = clamp(value.x, 0.0f, 1.0f);
temp.y = clamp(value.y, 0.0f, 1.0f);
temp.z = clamp(value.z, 0.0f, 1.0f);
temp.x = clamp_def(value.x, 0.0f, 1.0f);
temp.y = clamp_def(value.y, 0.0f, 1.0f);
temp.z = clamp_def(value.z, 0.0f, 1.0f);
if (memcmp(&temp, &data.tone_trans_start, sizeof(vec3))) {
data.tone_trans_start = temp;
data.update = true;
@@ -367,11 +373,8 @@ void post_process_tone_map::set_tone_trans_start(const vec3& value) {
}
static void post_process_tone_map_calculate_data(post_process_tone_map* tm) {
vec3 tone_trans, tone_trans_scale, tone_trans_offset;
vec3_sub(tm->data.tone_trans_end, tm->data.tone_trans_start, tone_trans);
vec3_rcp(tone_trans, tone_trans_scale);
vec3_mult(tone_trans_scale, tm->data.tone_trans_start, tone_trans_offset);
vec3_negate(tone_trans_offset, tone_trans_offset);
vec3 tone_trans_scale = vec3::rcp(tm->data.tone_trans_end - tm->data.tone_trans_start);
vec3 tone_trans_offset = -(tone_trans_scale * tm->data.tone_trans_start);
post_process_tone_map_shader_data* v = &tm->shader_data;
v->p_exposure.x = tm->data.exposure;
@@ -385,7 +388,7 @@ static void post_process_tone_map_calculate_data(post_process_tone_map* tm) {
v->p_flare_coef.w = 0.0f;
v->p_fade_color = tm->data.scene_fade;
if (tm->data.scene_fade_blend_func == 1 || tm->data.scene_fade_blend_func == 2)
vec3_mult_scalar(*(vec3*)&v->p_fade_color, v->p_fade_color.w, *(vec3*)&v->p_fade_color);
*(vec3*)&v->p_fade_color = *(vec3*)&v->p_fade_color * v->p_fade_color.w;
v->p_tone_scale.x = tone_trans_scale.x;
v->p_tone_scale.y = tone_trans_scale.y;
v->p_tone_scale.z = tone_trans_scale.z;
src/CRE/post_process/tone_map.hpp
+2
View File
@@ -43,6 +43,8 @@ struct post_process_tone_map_data {
float_t lens_flare_appear_power;
bool update;
bool update_tex;
post_process_tone_map_data();
};
struct post_process_tone_map {
src/CRE/pv_db.cpp
+2 -2
View File
@@ -775,7 +775,7 @@ namespace pv_db {
if (!kv.has_key(buf) || !kv.open_scope(buf))
return false;
size_t base_scope_index = kv.curr_scope - kv.scope.data();;
size_t base_scope_index = kv.curr_scope - kv.scope.data();
std::string song_name;
if (!kv.read("song_name", song_name)) {
@@ -1777,7 +1777,7 @@ namespace pv_db {
if (!kv.open_scope_fmt("%02d", k))
continue;
pv_db_pv_field field;;
pv_db_pv_field field;
const char* stage;
if (kv.read("stage", stage))
src/CRE/pv_expression.cpp
+2 -1
View File
@@ -37,7 +37,7 @@ struct pv_expression {
bool set_motion(uint32_t, int32_t motion_id);
};
pv_expression pv_expression_array[6];
pv_expression pv_expression_array[ROB_CHARA_COUNT];
extern render_context* rctx_ptr;
@@ -178,6 +178,7 @@ void pv_expression_file_unload(const char* file) {
i->file_handler.free_data();
}
delete i;
pv_expression_file_storage.erase(pv_expression_file_storage.begin()
+ (&i - pv_expression_file_storage.data()));
src/CRE/pv_param.cpp
+36 -35
View File
@@ -6,6 +6,7 @@
#include "pv_param.hpp"
#include "post_process.hpp"
#include "render_context.hpp"
#include "../KKdLib/io/file_stream.hpp"
#include "../KKdLib/str_utils.hpp"
extern render_context* rctx_ptr;
@@ -100,13 +101,13 @@ namespace pv_param {
char* buf;
char** lines;
size_t count;
if (!str_utils_text_file_parse(data.c_str(), data.size(), &buf, &lines, &count))
if (!str_utils_text_file_parse(data.c_str(), data.size(), buf, lines, count))
return false;
if (count <= 1 || str_utils_compare(lines[0],
"ID,ColorR,ColorG,ColorB,BrightpassR,BrightpassG,BrightpassB,Range")) {
free(buf);
free(lines);
free_def(buf);
free_def(lines);
return false;
}
@@ -128,8 +129,8 @@ namespace pv_param {
lines--;
free(buf);
free(lines);
free_def(buf);
free_def(lines);
return true;
}
@@ -141,13 +142,13 @@ namespace pv_param {
char* buf;
char** lines;
size_t count;
if (!str_utils_text_file_parse(data.c_str(), data.size(), &buf, &lines, &count))
if (!str_utils_text_file_parse(data.c_str(), data.size(), buf, lines, count))
return false;
if (count <= 1 || str_utils_compare(lines[0],
"ID,Hue,Saturation,Lightness,Exposure,GammaR,GammaG,GammaB,Contrast")) {
free(buf);
free(lines);
free_def(buf);
free_def(lines);
return false;
}
@@ -169,8 +170,8 @@ namespace pv_param {
lines--;
free(buf);
free(lines);
free_def(buf);
free_def(lines);
return true;
}
@@ -182,13 +183,13 @@ namespace pv_param {
char* buf;
char** lines;
size_t count;
if (!str_utils_text_file_parse(data.c_str(), data.size(), &buf, &lines, &count))
if (!str_utils_text_file_parse(data.c_str(), data.size(), buf, lines, count))
return false;
if (count <= 1 || str_utils_compare(lines[0],
"ID,Focus,FocusRange,FuzzingRange,Ratio,Quality")) {
free(buf);
free(lines);
free_def(buf);
free_def(lines);
return false;
}
@@ -210,8 +211,8 @@ namespace pv_param {
lines--;
free(buf);
free(lines);
free_def(buf);
free_def(lines);
return true;
}
@@ -410,14 +411,14 @@ namespace pv_param {
}
static bool load_text_file(void* data, const char* path, const char* file, uint32_t hash) {
stream s;
file_stream s;
s.open((std::string(path) + file).c_str(), "rb");
if (!s.io.stream)
return false;
*(std::string*)data = s.read_string(s.length);
s.close();
return true;
if (s.check_not_null()) {
*(std::string*)data = s.read_string(s.length);
s.close();
return true;
}
return false;
}
}
@@ -459,7 +460,7 @@ namespace pv_param_task {
else if (duration < 0.0f)
value = data.data_prev.color;
else
vec3_lerp_scalar(data.data_prev.color, data.data.color, value, frame / duration);
value = vec3::lerp(data.data_prev.color, data.data.color, frame / duration);
rctx_ptr->post_process.blur->set_intensity(value);
@@ -509,10 +510,10 @@ namespace pv_param_task {
}
else {
float_t t = frame / duration;
saturation = lerp(data.data_prev.saturation, data.data.saturation, t);
exposure = lerp(data.data_prev.exposure, data.data.exposure, t);
vec3_lerp_scalar(data.data_prev.gamma, data.data.gamma, gamma, t);
contrast = lerp(data.data_prev.contrast, data.data.contrast, t);
saturation = lerp_def(data.data_prev.saturation, data.data.saturation, t);
exposure = lerp_def(data.data_prev.exposure, data.data.exposure, t);
gamma = vec3::lerp(data.data_prev.gamma, data.data.gamma, t);
contrast = lerp_def(data.data_prev.contrast, data.data.contrast, t);
}
post_process_tone_map* tone_map = rctx_ptr->post_process.tone_map;
@@ -536,7 +537,7 @@ namespace pv_param_task {
}
void PostProcessCtrlCC::CalcToneTrans(float_t value, float_t& tone_trans_start, float_t& tone_trans_end) {
float_t pow = max(value, 0.125f) * 0.5f;
float_t pow = max_def(value, 0.125f) * 0.5f;
if (fabsf(value - 2.0f) < 0.000001f) {
tone_trans_start = 0.0f;
tone_trans_end = 1.0f;
@@ -582,7 +583,7 @@ namespace pv_param_task {
else if (i.duration <= 0.0)
value = i.prev_alpha;
else
value = lerp(i.prev_alpha, i.alpha, i.frame / i.duration);
value = lerp_def(i.prev_alpha, i.alpha, i.frame / i.duration);
draw_task_flags draw_task_flags;
switch (i.type) {
@@ -642,7 +643,7 @@ namespace pv_param_task {
else if (i.duration <= 0.0)
value = i.prev_alpha;
else
value = lerp(i.prev_alpha, i.alpha, i.frame / i.duration);
value = lerp_def(i.prev_alpha, i.alpha, i.frame / i.duration);
if (callback)
callback[index](callback_data[index], index, i.type, value);
@@ -707,7 +708,7 @@ namespace pv_param_task {
cam->get_view_point(view_point);
float_t fov = (float_t)cam->get_fov();
vec3_distance(trans, view_point, focus);
focus = vec3::distance(trans, view_point);
float_t v5 = tanf(fov * DEG_TO_RAD_FLOAT * 0.5f);
float_t v6 = focus * 1000.0f;
@@ -773,10 +774,10 @@ namespace pv_param_task {
}
else {
float_t t = frame / duration;
focus = lerp(data.data_prev.focus, data.data.focus, t);
focus_range = lerp(data.data_prev.focus_range, data.data.focus_range, t);
fuzzing_range = lerp(data.data_prev.fuzzing_range, data.data.fuzzing_range, t);
ratio = lerp(data.data_prev.ratio, data.data.ratio, t);
focus = lerp_def(data.data_prev.focus, data.data.focus, t);
focus_range = lerp_def(data.data_prev.focus_range, data.data.focus_range, t);
fuzzing_range = lerp_def(data.data_prev.fuzzing_range, data.data.fuzzing_range, t);
ratio = lerp_def(data.data_prev.ratio, data.data.ratio, t);
}
#if DOF_FIX
src/CRE/random.cpp
+6 -6
View File
@@ -15,17 +15,17 @@ RandState::~RandState() {
}
inline void rand_state_array_init() {
void rand_state_array_init() {
rand_state_array = new RandState[5];
}
inline RandState* rand_state_array_get(int32_t id) {
RandState* rand_state_array_get(int32_t id) {
if (id > -1 && id < 5)
return &rand_state_array[id];
return 0;
}
inline float_t rand_state_array_get_float(int32_t id) {
float_t rand_state_array_get_float(int32_t id) {
RandState* rand_state = rand_state_array_get(id);
if (rand_state) {
std::uniform_int_distribution<uint32_t> dis;
@@ -34,7 +34,7 @@ inline float_t rand_state_array_get_float(int32_t id) {
return 0.0f;
}
inline uint32_t rand_state_array_get_int(int32_t id) {
uint32_t rand_state_array_get_int(int32_t id) {
RandState* rand_state = rand_state_array_get(id);
if (rand_state) {
std::uniform_int_distribution<uint32_t> dis;
@@ -43,7 +43,7 @@ inline uint32_t rand_state_array_get_int(int32_t id) {
return 0;
}
inline uint32_t rand_state_array_get_int(uint32_t min, uint32_t max, int32_t id) {
uint32_t rand_state_array_get_int(uint32_t min, uint32_t max, int32_t id) {
uint64_t _min = min;
uint64_t _max = max;
RandState* rand_state = rand_state_array_get(id);
@@ -54,6 +54,6 @@ inline uint32_t rand_state_array_get_int(uint32_t min, uint32_t max, int32_t id)
return 0;
}
inline void rand_state_array_free() {
void rand_state_array_free() {
delete[] rand_state_array;
}
src/CRE/render_context.cpp
+295 -179
View File
@@ -10,6 +10,7 @@
#include "draw_task.hpp"
#include "file_handler.hpp"
#include "shader_ft.hpp"
#include "sound.hpp"
#include "stage.hpp"
float_t delta_frame_history = 0;
@@ -24,7 +25,7 @@ sss_data::sss_data() : init(), enable(), npr_contour(), param() {
npr_contour = true;
param = { 0.0f, 0.0f, 0.0f, 1.0f };
textures[0].init(640, 360, 0, GL_RGBA16F, GL_DEPTH24_STENCIL8);
textures[0].init(640, 360, 0, GL_RGBA16F, GL_DEPTH_COMPONENT32F);
textures[1].init(320, 180, 0, GL_RGBA16F, GL_ZERO);
textures[2].init(320, 180, 0, GL_RGBA16F, GL_ZERO);
textures[3].init(320, 180, 0, GL_RGBA16F, GL_ZERO);
@@ -46,8 +47,8 @@ field_2F8(), sss_texture(), npr_param(), field_31C(), field_31D(), field_31E(),
alpha_z_sort = true;
for (bool& i : draw_pass_3d)
i = true;
reflect_texture.init(512, 256, 0, GL_RGBA16F, GL_DEPTH24_STENCIL8);
refract_texture.init(512, 256, 0, GL_RGBA8, GL_DEPTH24_STENCIL8);
reflect_texture.init(512, 256, 0, GL_RGBA16F, GL_DEPTH_COMPONENT32F);
refract_texture.init(512, 256, 0, GL_RGBA8, GL_DEPTH_COMPONENT32F);
shadow_ptr = new ::shadow;
if (shadow_ptr)
shadow_ptr->init_data();
@@ -99,9 +100,9 @@ texture_transform_struct::texture_transform_struct(uint32_t id, mat4& mat) : id(
}
light_proj::light_proj(int32_t width, int32_t height) : enable(), texture_id() {
shadow_texture[0].init(2048, 512, 0, GL_R32F, GL_DEPTH24_STENCIL8);
shadow_texture[0].init(2048, 512, 0, GL_R32F, GL_DEPTH_COMPONENT32F);
shadow_texture[1].init(2048, 512, 0, GL_R32F, GL_ZERO);
draw_texture.init(width, height, 0, GL_RGBA8, GL_DEPTH24_STENCIL8);
draw_texture.init(width, height, 0, GL_RGBA8, GL_DEPTH_COMPONENT32F);
}
light_proj::~light_proj() {
@@ -112,7 +113,7 @@ void light_proj::resize(int32_t width, int32_t height) {
if (!this)
return;
draw_texture.init(width, height, 0, GL_RGBA8, GL_DEPTH24_STENCIL8);
draw_texture.init(width, height, 0, GL_RGBA8, GL_DEPTH_COMPONENT32F);
}
bool light_proj::set(render_context* rctx) {
@@ -183,16 +184,13 @@ bool light_proj::set_mat(render_context* rctx, bool set_mat) {
data->get_position(position);
data->get_spot_direction(spot_direction);
float_t length;
vec3_length_squared(spot_direction, length);
if (length <= 0.000001f)
if (vec3::length_squared(spot_direction) <= 0.000001f)
return false;
float_t spot_cutoff = data->get_spot_cutoff();
float_t fov = atanf(tanf(spot_cutoff * DEG_TO_RAD_FLOAT) * 0.25f) * (RAD_TO_DEG_FLOAT * 2.0f);
vec3 interest;
vec3_add(position, spot_direction, interest);
vec3 interest = position + spot_direction;
if (set_mat) {
mat4 mat;
get_proj_mat(&position, &interest, fov, &mat);
@@ -215,7 +213,7 @@ object_data_buffer::object_data_buffer() {
}
object_data_buffer::~object_data_buffer() {
free(data);
free_def(data);
}
draw_task* object_data_buffer::add_draw_task(draw_task_type type) {
@@ -297,15 +295,33 @@ void object_data::add_vertex_array(draw_object* draw) {
GLuint array_buffer = draw->array_buffer;
GLuint morph_array_buffer = draw->morph_array_buffer;
int32_t texcoord_array[2] = { -1, -1 };
int32_t color_tex_index = 0;
for (obj_material_texture_data& i : material->material.texdata) {
if (i.tex_index == -1)
continue;
int32_t texcoord_index = obj_material_texture_type_get_texcoord_index(
i.shader_info.m.tex_type, color_tex_index);
if (texcoord_index < 0)
continue;
texcoord_array[texcoord_index] = sub_mesh->uv_index[&i - material->material.texdata];
if (i.shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR)
color_tex_index++;
}
object_data_vertex_array* vertex_array_data = 0;
for (object_data_vertex_array& i : vertex_array_cache)
if (i.alive_time >= 0 && i.array_buffer == array_buffer && i.morph_array_buffer == morph_array_buffer) {
if (i.alive_time >= 0 && i.array_buffer == array_buffer && i.morph_array_buffer == morph_array_buffer
&& !memcmp(i.texcoord_array, texcoord_array, sizeof(texcoord_array))) {
if (!i.vertex_array) {
vertex_array_data = &i;
break;
}
i.alive_time = 60;
i.alive_time = 2;
return;
}
@@ -327,7 +343,8 @@ void object_data::add_vertex_array(draw_object* draw) {
vertex_array_data->array_buffer = array_buffer;
vertex_array_data->morph_array_buffer = morph_array_buffer;
vertex_array_data->alive_time = 60;
vertex_array_data->alive_time = 2;
memcpy(&vertex_array_data->texcoord_array, texcoord_array, sizeof(texcoord_array));
bool compressed = mesh->attrib.m.compressed;
GLsizei size_vertex = (GLsizei)mesh->size_vertex;
@@ -339,15 +356,26 @@ void object_data::add_vertex_array(draw_object* draw) {
size_t offset = 0;
if (vertex_format & OBJ_VERTEX_POSITION) {
glEnableVertexAttribArray(0);
if (!vertex_array_data->vertex_attrib_array[0]) {
glEnableVertexAttribArray(0);
vertex_array_data->vertex_attrib_array[0] = true;
}
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset);
offset += 12;
}
else
else if (vertex_array_data->vertex_attrib_array[0]) {
glDisableVertexAttribArray(0);
glVertexAttrib4f(0, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[0] = false;
}
if (vertex_format & OBJ_VERTEX_NORMAL) {
glEnableVertexAttribArray(2);
if (!vertex_array_data->vertex_attrib_array[2]) {
glEnableVertexAttribArray(2);
vertex_array_data->vertex_attrib_array[2] = true;
}
if (!compressed) {
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset);
offset += 12;
@@ -357,11 +385,18 @@ void object_data::add_vertex_array(draw_object* draw) {
offset += 8;
}
}
else
else if (vertex_array_data->vertex_attrib_array[2]) {
glDisableVertexAttribArray(2);
glVertexAttrib4f(2, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[2] = false;
}
if (vertex_format & OBJ_VERTEX_TANGENT) {
glEnableVertexAttribArray(6);
if (!vertex_array_data->vertex_attrib_array[6]) {
glEnableVertexAttribArray(6);
vertex_array_data->vertex_attrib_array[6] = true;
}
if (!compressed) {
glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset);
offset += 16;
@@ -371,42 +406,40 @@ void object_data::add_vertex_array(draw_object* draw) {
offset += 8;
}
}
else
glVertexAttrib4f(5, 0.0f, 0.0f, 0.0f, 1.0f);
else if (vertex_array_data->vertex_attrib_array[6]) {
glDisableVertexAttribArray(6);
glVertexAttrib4f(6, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[6] = false;
}
if (!compressed && vertex_format & OBJ_VERTEX_BINORMAL)
offset += 12;
bool texture_vertex_attrib_array_set[4] = { false };
for (int32_t i = 0, j = 0, l = 0; i < 4; i++) {
if (material->material.texdata[i].tex_index == -1)
for (int32_t i = 0; i < 2; i++) {
int32_t texcoord_index = texcoord_array[i];
if (texcoord_index < 0) {
if (vertex_array_data->vertex_attrib_array[8 + i]) {
glDisableVertexAttribArray(8 + i);
glVertexAttrib4f(8 + i, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[8 + i] = false;
}
continue;
int32_t texcoord_index = obj_material_texture_type_get_texcoord_index(
material->material.texdata[i].shader_info.m.tex_type, j);
if (texcoord_index < 0)
continue;
if (material->material.texdata[i].shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR)
j++;
if (vertex_format & (OBJ_VERTEX_TEXCOORD0 << sub_mesh->uv_index[l])
&& !texture_vertex_attrib_array_set[sub_mesh->uv_index[l]]) {
glEnableVertexAttribArray(8 + texcoord_index);
if (!compressed)
glVertexAttribPointer(8 + texcoord_index, 2, GL_FLOAT, GL_FALSE,
size_vertex, (void*)(offset + 8ULL * sub_mesh->uv_index[l]));
else
glVertexAttribPointer(8 + texcoord_index, 2, GL_HALF_FLOAT, GL_FALSE,
size_vertex, (void*)(offset + 4ULL * sub_mesh->uv_index[l]));
texture_vertex_attrib_array_set[sub_mesh->uv_index[l]] = true;
}
l++;
}
for (int32_t i = 0; i < 4; i++)
if (!texture_vertex_attrib_array_set[i])
glVertexAttrib4f(8 + i, 0.0f, 0.0f, 0.0f, 1.0f);
if (vertex_format & (OBJ_VERTEX_TEXCOORD0 << i)) {
if (!vertex_array_data->vertex_attrib_array[8 + i]) {
glEnableVertexAttribArray(8 + i);
vertex_array_data->vertex_attrib_array[8 + i] = true;
}
if (!compressed)
glVertexAttribPointer(8 + i, 2, GL_FLOAT, GL_FALSE,
size_vertex, (void*)(offset + 8ULL * texcoord_index));
else
glVertexAttribPointer(8 + i, 2, GL_HALF_FLOAT, GL_FALSE,
size_vertex, (void*)(offset + 4ULL * texcoord_index));
}
}
if (!compressed) {
if (vertex_format & OBJ_VERTEX_TEXCOORD0)
@@ -430,7 +463,11 @@ void object_data::add_vertex_array(draw_object* draw) {
}
if (vertex_format & OBJ_VERTEX_COLOR0) {
glEnableVertexAttribArray(3);
if (!vertex_array_data->vertex_attrib_array[3]) {
glEnableVertexAttribArray(3);
vertex_array_data->vertex_attrib_array[3] = true;
}
if (!compressed) {
glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset);
offset += 16;
@@ -440,14 +477,21 @@ void object_data::add_vertex_array(draw_object* draw) {
offset += 8;
}
}
else
else if (vertex_array_data->vertex_attrib_array[3]) {
glDisableVertexAttribArray(3);
glVertexAttrib4f(3, 1.0f, 1.0f, 1.0f, 1.0f);
vertex_array_data->vertex_attrib_array[3] = false;
}
if (vertex_format & OBJ_VERTEX_COLOR1)
offset += 16;
if (vertex_format & OBJ_VERTEX_BONE_DATA) {
glEnableVertexAttribArray(1);
if (!vertex_array_data->vertex_attrib_array[1]) {
glEnableVertexAttribArray(1);
vertex_array_data->vertex_attrib_array[1] = true;
}
if (!compressed) {
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset);
offset += 16;
@@ -457,7 +501,11 @@ void object_data::add_vertex_array(draw_object* draw) {
offset += 8;
}
glEnableVertexAttribArray(15);
if (!vertex_array_data->vertex_attrib_array[15]) {
glEnableVertexAttribArray(15);
vertex_array_data->vertex_attrib_array[15] = true;
}
if (!compressed) {
glVertexAttribPointer(15, 4, GL_INT, GL_FALSE, size_vertex, (void*)offset);
offset += 16;
@@ -468,32 +516,59 @@ void object_data::add_vertex_array(draw_object* draw) {
}
}
else {
glVertexAttrib4f(1, 0.0f, 0.0f, 0.0f, 0.0f);
glVertexAttrib4f(15, 0.0f, 0.0f, 0.0f, 0.0f);
if (vertex_array_data->vertex_attrib_array[1]) {
glDisableVertexAttribArray(1);
glVertexAttrib4f(1, 0.0f, 0.0f, 0.0f, 0.0f);
vertex_array_data->vertex_attrib_array[1] = false;
}
if (vertex_array_data->vertex_attrib_array[15]) {
glDisableVertexAttribArray(15);
glVertexAttrib4f(15, 0.0f, 0.0f, 0.0f, 0.0f);
vertex_array_data->vertex_attrib_array[15] = false;
}
}
if (!compressed && vertex_format & OBJ_VERTEX_UNKNOWN) {
glEnableVertexAttribArray(7);
if (!vertex_array_data->vertex_attrib_array[7]) {
glEnableVertexAttribArray(7);
vertex_array_data->vertex_attrib_array[7] = true;
}
glVertexAttribPointer(7, 4, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset);
offset += 16;
}
else
else if (vertex_array_data->vertex_attrib_array[7]) {
glDisableVertexAttribArray(7);
glVertexAttrib4f(7, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[7] = false;
}
if (draw->morph_array_buffer) {
gl_state_bind_array_buffer(draw->morph_array_buffer);
offset = 0;
if (vertex_format & OBJ_VERTEX_POSITION) {
glEnableVertexAttribArray(10);
if (!vertex_array_data->vertex_attrib_array[10]) {
glEnableVertexAttribArray(10);
vertex_array_data->vertex_attrib_array[10] = true;
}
glVertexAttribPointer(10, 3, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset);
offset += 12;
}
else
else if (vertex_array_data->vertex_attrib_array[10]) {
glDisableVertexAttribArray(10);
glVertexAttrib4f(10, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[10] = false;
}
if (vertex_format & OBJ_VERTEX_NORMAL) {
glEnableVertexAttribArray(11);
if (!vertex_array_data->vertex_attrib_array[11]) {
glEnableVertexAttribArray(11);
vertex_array_data->vertex_attrib_array[11] = true;
}
if (!compressed) {
glVertexAttribPointer(11, 3, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset);
offset += 12;
@@ -503,11 +578,18 @@ void object_data::add_vertex_array(draw_object* draw) {
offset += 8;
}
}
else
else if (vertex_array_data->vertex_attrib_array[11]) {
glDisableVertexAttribArray(11);
glVertexAttrib4f(11, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[11] = false;
}
if (vertex_format & OBJ_VERTEX_TANGENT) {
glEnableVertexAttribArray(12);
if (!vertex_array_data->vertex_attrib_array[12]) {
glEnableVertexAttribArray(12);
vertex_array_data->vertex_attrib_array[12] = true;
}
if (!compressed) {
glVertexAttribPointer(12, 4, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset);
offset += 16;
@@ -517,14 +599,21 @@ void object_data::add_vertex_array(draw_object* draw) {
offset += 8;
}
}
else
else if (vertex_array_data->vertex_attrib_array[12]) {
glDisableVertexAttribArray(12);
glVertexAttrib4f(12, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[12] = false;
}
if (!compressed && vertex_format & OBJ_VERTEX_BINORMAL)
offset += 12;
if (vertex_format & OBJ_VERTEX_TEXCOORD0) {
glEnableVertexAttribArray(13);
if (!vertex_array_data->vertex_attrib_array[13]) {
glEnableVertexAttribArray(13);
vertex_array_data->vertex_attrib_array[13] = true;
}
if (!compressed) {
glVertexAttribPointer(13, 2, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset);
offset += 8;
@@ -534,11 +623,18 @@ void object_data::add_vertex_array(draw_object* draw) {
offset += 4;
}
}
else
else if (vertex_array_data->vertex_attrib_array[13]) {
glDisableVertexAttribArray(13);
glVertexAttrib4f(13, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[13] = false;
}
if (vertex_format & OBJ_VERTEX_TEXCOORD1) {
glEnableVertexAttribArray(14);
if (!vertex_array_data->vertex_attrib_array[14]) {
glEnableVertexAttribArray(14);
vertex_array_data->vertex_attrib_array[14] = true;
}
if (!compressed) {
glVertexAttribPointer(14, 2, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset);
offset += 8;
@@ -548,8 +644,11 @@ void object_data::add_vertex_array(draw_object* draw) {
offset += 4;
}
}
else
else if (vertex_array_data->vertex_attrib_array[14]) {
glDisableVertexAttribArray(14);
glVertexAttrib4f(14, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[14] = false;
}
if (!compressed) {
if (vertex_format & OBJ_VERTEX_TEXCOORD2)
@@ -567,7 +666,11 @@ void object_data::add_vertex_array(draw_object* draw) {
if (vertex_format & OBJ_VERTEX_COLOR0) {
uniform_value[U_MORPH_COLOR] = 1;
glEnableVertexAttribArray(5);
if (!vertex_array_data->vertex_attrib_array[5]) {
glEnableVertexAttribArray(5);
vertex_array_data->vertex_attrib_array[5] = true;
}
if (!compressed) {
glVertexAttribPointer(5, 4, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset);
offset += 16;
@@ -577,8 +680,11 @@ void object_data::add_vertex_array(draw_object* draw) {
offset += 8;
}
}
else
else if (vertex_array_data->vertex_attrib_array[5]) {
glDisableVertexAttribArray(5);
glVertexAttrib4f(5, 1.0f, 1.0f, 1.0f, 1.0f);
vertex_array_data->vertex_attrib_array[5] = false;
}
if (!compressed) {
if (vertex_format & OBJ_VERTEX_COLOR1)
@@ -594,9 +700,45 @@ void object_data::add_vertex_array(draw_object* draw) {
if (vertex_format & OBJ_VERTEX_BONE_DATA)
offset += 16;
}
shaders_ft.env_vert_set(13, draw->morph_value, 1.0f - draw->morph_value, 0.0f, 0.0f);
}
else {
if (vertex_array_data->vertex_attrib_array[10]) {
glDisableVertexAttribArray(10);
glVertexAttrib4f(10, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[10] = false;
}
if (vertex_array_data->vertex_attrib_array[11]) {
glDisableVertexAttribArray(11);
glVertexAttrib4f(11, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[11] = false;
}
if (vertex_array_data->vertex_attrib_array[12]) {
glDisableVertexAttribArray(12);
glVertexAttrib4f(12, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[12] = false;
}
if (vertex_array_data->vertex_attrib_array[13]) {
glDisableVertexAttribArray(13);
glVertexAttrib4f(13, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[13] = false;
}
if (vertex_array_data->vertex_attrib_array[14]) {
glDisableVertexAttribArray(14);
glVertexAttrib4f(14, 0.0f, 0.0f, 0.0f, 1.0f);
vertex_array_data->vertex_attrib_array[14] = false;
}
if (vertex_array_data->vertex_attrib_array[5]) {
glDisableVertexAttribArray(5);
glVertexAttrib4f(5, 1.0f, 1.0f, 1.0f, 1.0f);
vertex_array_data->vertex_attrib_array[5] = false;
}
}
gl_state_bind_array_buffer(0);
gl_state_bind_vertex_array(0);
gl_state_bind_element_array_buffer(0);
@@ -611,9 +753,35 @@ void object_data::check_vertex_arrays() {
}
}
GLuint object_data::get_vertex_array(GLuint array_buffer, GLuint morph_array_buffer) {
GLuint object_data::get_vertex_array(draw_object* draw) {
obj_mesh* mesh = draw->mesh;
obj_sub_mesh* sub_mesh = draw->sub_mesh;
obj_material_data* material = draw->material;
GLuint array_buffer = draw->array_buffer;
GLuint morph_array_buffer = draw->morph_array_buffer;
int32_t texcoord_array[2] = { -1, -1 };
int32_t color_tex_index = 0;
for (obj_material_texture_data& i : material->material.texdata) {
if (i.tex_index == -1)
continue;
int32_t texcoord_index = obj_material_texture_type_get_texcoord_index(
i.shader_info.m.tex_type, color_tex_index);
if (texcoord_index < 0)
continue;
texcoord_array[texcoord_index] = sub_mesh->uv_index[&i - material->material.texdata];
if (i.shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR)
color_tex_index++;
}
object_data_vertex_array* vertex_array_data = 0;
for (object_data_vertex_array& i : vertex_array_cache)
if (i.alive_time > 0 && i.array_buffer == array_buffer && i.morph_array_buffer == morph_array_buffer)
if (i.alive_time > 0 && i.array_buffer == array_buffer && i.morph_array_buffer == morph_array_buffer
&& !memcmp(i.texcoord_array, texcoord_array, sizeof(texcoord_array)))
return i.vertex_array;
return 0;
}
@@ -836,7 +1004,7 @@ void render_context::ctrl() {
rctx_ptr = this;
app::TaskWork::Ctrl();
sound_ctrl();
file_handler_storage_ctrl();
draw_pass.shadow_ptr->ctrl(this);
@@ -1006,7 +1174,7 @@ void render_context::light_param_data_ibl_set(
light_data* l = &set->lights[LIGHT_CHARA];
l->get_position(pos);
vec3_length(pos, len);
len = vec3::length(pos);
if (fabsf(len - 1.0f) < 0.02f)
l->set_position(ibl->lit_dir[0]);
@@ -1016,7 +1184,7 @@ void render_context::light_param_data_ibl_set(
l = &set->lights[LIGHT_STAGE];
l->get_position(pos);
vec3_length(pos, len);
len = vec3::length(pos);
if (fabsf(len - 1.0f) < 0.02f)
l->set_position(ibl->lit_dir[1]);
@@ -1081,8 +1249,7 @@ field_1A8(), view_point_shared(), interest_shared(), field_2F0() {
field_2E0 = 0.05f;
ambient = 0.4f;
field_2EC = 0;
direction = { 0.0f, -1.0f, -1.0f };
vec3_mult_scalar(direction, 1.0f / sqrtf(2.0f), direction);
direction = vec3(0.0f, -1.0f, -1.0f) * (1.0f / sqrtf(2.0f));
field_2E8 = false;
self_shadow = true;
blur_filter_enable[0] = true;
@@ -1107,14 +1274,12 @@ void shadow::ctrl(render_context* rctx) {
light_data* data = &set->lights[LIGHT_CHARA];
vec3 position;
float_t length;
data->get_position(position);
vec3_negate(position, position);
vec3_length(position, length);
if (length < 0.000001)
float_t length = vec3::length(position);
if (length < 0.000001f)
direction = { 0.0f, 1.0f, 0.0f };
else
vec3_mult_scalar(position, 1.0f / length, direction);
direction = -position * (1.0f / length);
for (int32_t i = 0; i < 2; i++)
if (draw_task_get_count(rctx, (draw_object_type)((int32_t)DRAW_OBJECT_SHADOW_CHARA + i)))
@@ -1140,23 +1305,18 @@ void shadow::ctrl(render_context* rctx) {
vec3 v7 = vec3_null;
for (vec3& j : field_1D0[i])
vec3_add(v7, j, v7);
v7 += j;
float_t v14 = (float_t)(int32_t)field_1D0[i].size();
if (v14 < 0.0f)
v14 += 1.8446744e19f;
vec3_mult_scalar(v7, 1.0f / v14, v7);
v7 *= 1.0f / v14;
float_t v15 = 0.0f;
for (vec3& j : field_1D0[i]) {
vec3 v22;
vec3_sub(v7, j, v22);
float_t v23;
vec3_dot(v22, direction, v23);
vec3 v25;
vec3_mult_scalar(direction, v23, v25);
float_t v24;
vec3_distance(v25, v22, v24);
vec3 v22 = v7 - j;
vec3 v25 = direction * vec3::dot(v22, direction);
float_t v24 = vec3::distance(v25, v22);
v24 -= 0.25f;
if (v24 < 0.0f)
v24 = 0.0f;
@@ -1174,49 +1334,35 @@ void shadow::ctrl(render_context* rctx) {
if (!field_2F0[i])
continue;
vec3 v11;
vec3_mult_scalar(direction, field_208, v11);
vec3_sub(field_1A8[i], v11, v11);
float_t v9;
vec3_distance(this->view_point[i], v11, v9);
float_t v12;
vec3_distance(this->interest[i], field_1A8[i], v12);
vec3 v11 = field_1A8[i] - direction * field_208;
float_t v9 = vec3::distance(this->view_point[i], v11);
float_t v12 = vec3::distance(this->interest[i], field_1A8[i]);
if (v9 > 0.1f || v12 > 0.1f) {
this->view_point[i] = v11;
this->interest[i] = field_1A8[i];
}
vec3_add(view_point, this->view_point[i], view_point);
vec3_add(interest, this->interest[i], interest);
view_point += this->view_point[i];
interest += this->interest[i];
}
vec3_mult_scalar(view_point, 1.0f / field_2EC, view_point_shared);
vec3_mult_scalar(interest, 1.0f / field_2EC, interest_shared);
view_point_shared = view_point * (1.0f / field_2EC);
interest_shared = interest * (1.0f / field_2EC);
}
float_t v2 = max(field_1C8[0], field_1C8[1]);
float_t v2 = max_def(field_1C8[0], field_1C8[1]);
field_2F5 = false;
view_region = v2 + 1.2f;
field_200[0] = 0;
field_200[1] = 1;
if (field_2EC >= 2) {
vec3 v12;
vec3_sub(field_1A8[0], interest_shared, v12);
vec3 v12 = field_1A8[0] - interest_shared;
vec3 v14 = field_1A8[1] - interest_shared;
float_t v15 = vec3::dot(v12, direction);
vec3 v14;
vec3_sub(field_1A8[1], interest_shared, v14);
vec3 v6 = direction * v15 - v12;
float_t v15;
vec3_dot(v12, direction, v15);
vec3 v6;
vec3_mult_scalar(direction, v15, v6);
vec3_sub(v6, v12, v6);
float_t v16;
vec3_length(v6, v16);
v16 -= 0.25f;
float_t v16 = vec3::length(v6) - 0.25f;
if (v16 < 0.0f)
v16 = 0.0f;
@@ -1227,11 +1373,7 @@ void shadow::ctrl(render_context* rctx) {
else
view_region = v2 + 1.2f + v16;
float_t t3;
float_t t4;
vec3_dot(v12, direction, t3);
vec3_dot(v14, direction, t4);
if (t3 < t4) {
if (vec3::dot(v12, direction) < vec3::dot(v14, direction)) {
field_200[1] = 0;
field_200[0] = 1;
}
@@ -1241,11 +1383,9 @@ void shadow::ctrl(render_context* rctx) {
vec3 v3;
vec3 v86;
if (direction.y * direction.y < 0.99f) {
vec3 up = { 0.0f, 1.0f, 0.0f };
vec3_cross(direction, up, v86);
vec3_cross(v86, direction, v3);
vec3_normalize(v3, v3);
vec3_normalize(v86, v86);
v86 = vec3::cross(direction, vec3(0.0f, 1.0f, 0.0f));
v3 = vec3::normalize(vec3::cross(v86, direction));
v86 = vec3::normalize(v86);
}
else {
v3 = { 0.0f, 0.0f, 1.0f };
@@ -1260,7 +1400,7 @@ void shadow::ctrl(render_context* rctx) {
vec3 v22 = vec3_null;
for (vec3& j : field_1D0[i])
vec3_add(v22, j, v22);
v22 += j;
int32_t v27 = (int32_t)field_1D0[i].size();
float_t v29 = (float_t)v27;
@@ -1268,18 +1408,12 @@ void shadow::ctrl(render_context* rctx) {
v29 += 1.8446744e19f;
float_t v30 = 0.0f;
vec3 v31;
vec3_mult_scalar(v22, 1.0f / v29, v31);
vec3 v31 = v22 * (1.0f / v29);
for (vec3& j : field_1D0[i]) {
vec3 v34;
vec3_sub(v31, j, v34);
float_t v38;
float_t v39;
vec3_dot(v34, v3, v38);
vec3_dot(v34, v86, v39);
v38 = fabsf(v38);
v39 = fabsf(v39);
vec3 v34 = v31 - j;
float_t v38 = fabsf(vec3::dot(v34, v3));
float_t v39 = fabsf(vec3::dot(v34, v86));
if (v39 >= v38)
v38 = v39;
if (v30 < v38)
@@ -1294,13 +1428,9 @@ void shadow::ctrl(render_context* rctx) {
if (!field_2F0[i])
continue;
float_t v51;
vec3 v53;
float_t v54;
vec3_mult_scalar(direction, field_208, v53);
vec3_sub(field_1A8[i], v53, v53);
vec3_distance(view_point[i], v53, v51);
vec3_distance(interest[i], field_1A8[i], v54);
vec3 v53 = field_1A8[i] - direction * field_208;
float_t v51 = vec3::distance(view_point[i], v53);
float_t v54 = vec3::distance(interest[i], field_1A8[i]);
if (v51 > 0.1f || v54 > 0.1f) {
view_point[i] = v53;
interest[i] = field_1A8[i];
@@ -1312,47 +1442,40 @@ void shadow::ctrl(render_context* rctx) {
int32_t count = 0;
for (int32_t i = 0; i < 2; i++) {
int32_t c = (int32_t)field_1D0[i].size();
vec3 view_point_temp;
vec3 interest_temp;
vec3_mult_scalar(this->view_point[i], (float_t)c, view_point_temp);
vec3_mult_scalar(this->interest[i], (float_t)c, interest_temp);
vec3_add(view_point, view_point_temp, view_point);
vec3_add(interest, interest_temp, interest);
view_point += this->view_point[i] * (float_t)c;
interest += this->interest[i] * (float_t)c;
count += c;
}
vec3_mult_scalar(view_point, 1.0f / (float_t)count, view_point_shared);
vec3_mult_scalar(interest, 1.0f / (float_t)count, interest_shared);
view_point_shared = view_point * (1.0f / (float_t)count);
interest_shared = interest * (1.0f / (float_t)count);
}
float_t v2 = 0.0;
float_t v67 = max(field_1C8[0], field_1C8[1]);
float_t v2 = 0.0f;
float_t v67 = max_def(field_1C8[0], field_1C8[1]);
field_2F5 = false;
view_region = v67 + 1.2f;
field_200[0] = 0;
field_200[1] = 1;
if (field_2EC >= 2) {
float_t v68 = 0.0;
float_t v69 = 0.0;
float_t v70 = 0.0;
float_t v68 = 0.0f;
float_t v69 = 0.0f;
float_t v70 = 0.0f;
for (int32_t i = 0; i < 2; i++) {
if (!field_2F0[i])
continue;
for (vec3& j : field_1D0[i]) {
vec3 v74;
vec3_sub(j, interest_shared, v74);
vec3 v74 = j - interest_shared;
float_t v77;
vec3_dot(v74, v86, v77);
if (v77 < v2)
float_t v77 = vec3::dot(v74, v86);
if (v2 > v77)
v2 = v77;
else if (v69 < v77)
v69 = v77;
float_t v78;
vec3_dot(v74, v3, v78);
if (v78 < v68)
float_t v78 = vec3::dot(v74, v3);
if (v68 > v78)
v68 = v78;
else if (v70 < v78)
v70 = v78;
@@ -1374,15 +1497,8 @@ void shadow::ctrl(render_context* rctx) {
else
view_region = v79 + 1.2f;
vec3 interest_chara;
vec3 interest_stage;
float_t interest_chara_cos;
float_t interest_stage_cos;
vec3_sub(field_1A8[0], interest_shared, interest_chara);
vec3_dot(interest_chara, direction, interest_chara_cos);
vec3_sub(field_1A8[1], interest_shared, interest_stage);
vec3_dot(interest_stage, direction, interest_stage_cos);
if (interest_chara_cos < interest_stage_cos) {
if (vec3::dot(field_1A8[0] - interest_shared, direction)
< vec3::dot(field_1A8[1] - interest_shared, direction)) {
field_200[1] = 0;
field_200[0] = 1;
}
@@ -1401,7 +1517,7 @@ int32_t shadow::init_data() {
GLenum color_format;
GLenum depth_format;
} init_params[] = {
{ 0x800, 0x800, 0, GL_RGBA8, GL_DEPTH24_STENCIL8 },
{ 0x800, 0x800, 0, GL_RGBA8, GL_DEPTH_COMPONENT32F },
{ 0x200, 0x200, 3, GL_RGBA8, GL_ZERO },
{ 0x200, 0x200, 3, GL_RGBA8, GL_ZERO },
{ 0x800, 0x800, 0, GL_R32F, GL_ZERO },
src/CRE/render_context.hpp
+3 -1
View File
@@ -441,6 +441,8 @@ struct object_data_vertex_array {
GLuint morph_array_buffer;
int32_t alive_time;
GLuint vertex_array;
bool vertex_attrib_array[16];
int32_t texcoord_array[2];
};
struct object_data {
@@ -480,7 +482,7 @@ struct object_data {
void add_vertex_array(draw_object* draw);
void check_vertex_arrays();
GLuint get_vertex_array(GLuint array_buffer, GLuint morph_array_buffer);
GLuint get_vertex_array(draw_object* draw);
bool get_chara_color();
::draw_task_flags get_draw_task_flags();
void get_material_list(int32_t& count, material_list_struct*& value);
src/CRE/render_texture.cpp
+4 -4
View File
@@ -78,7 +78,7 @@ int32_t render_texture::init(int32_t width, int32_t height,
if (max_level < 0)
return -1;
max_level = min(max_level, 15);
max_level = min_def(max_level, 15);
if (max_level < 0)
return 0;
free_data();
@@ -158,8 +158,8 @@ void render_texture::draw_custom_glsl() {
void render_texture::draw_params(shader_set_data* set, int32_t width, int32_t height,
float_t scale, float_t param_x, float_t param_y, float_t param_z, float_t param_w) {
float_t w = (float_t)max(width, 1);
float_t h = (float_t)max(height, 1);
float_t w = (float_t)max_def(width, 1);
float_t h = (float_t)max_def(height, 1);
set->local_vert_set(0, scale / w, scale / h, w, h);
set->local_frag_set(0, scale / w, scale / h, w, h);
set->local_vert_set(3, param_x, param_y, param_z, param_w);
@@ -211,7 +211,7 @@ void render_texture_data_init() {
"layout(binding = 0) uniform sampler2D g_color;\n"
"\n"
"void main() {\n"
" result = texture(g_color, frg.texcoord); \n"
" result = texture(g_color, frg.texcoord);\n"
"}\n";
shader_glsl_param param = {};
src/CRE/rob/ex_block.cpp
+19 -20
View File
@@ -177,9 +177,8 @@ static const exp_func_op3 exp_func_op3_array[] = {
osage_setting osage_setting_data;
size_t qword_140FBDF88 = 0;
static const int32_t rob_cloth_update_vertices_flags = 0x03;
static const bool rob_cloth_update_normals_select = false;
int32_t rob_cloth_update_vertices_flags = 0x03;
bool rob_cloth_update_normals_select = false;
ExNodeBlock::ExNodeBlock() : bone_node_ptr(), type(), name(), parent_bone_node(),
parent_name(), parent_node(), item_equip_object(), field_58(), field_59(), has_children_node() {
@@ -337,10 +336,10 @@ skin_param_hinge::~skin_param_hinge() {
}
void skin_param_hinge::limit() {
ymin = max(ymin, -179.0f) * DEG_TO_RAD_FLOAT;
ymax = min(ymax, 179.0f) * DEG_TO_RAD_FLOAT;
zmin = max(zmin, -179.0f) * DEG_TO_RAD_FLOAT;
zmax = min(zmax, 179.0f) * DEG_TO_RAD_FLOAT;
ymin = max_def(ymin, -179.0f) * DEG_TO_RAD_FLOAT;
ymax = min_def(ymax, 179.0f) * DEG_TO_RAD_FLOAT;
zmin = max_def(zmin, -179.0f) * DEG_TO_RAD_FLOAT;
zmax = min_def(zmax, 179.0f) * DEG_TO_RAD_FLOAT;
}
skin_param_osage_node::skin_param_osage_node() : coli_r(0.0f), weight(1.0f), inertial_cancel(0.0f) {
@@ -1559,8 +1558,8 @@ void RobOsage::SetForce(float_t force, float_t force_gain) {
}
void RobOsage::SetHinge(float_t hinge_y, float_t hinge_z) {
hinge_y = min(hinge_y, 179.0f);
hinge_z = min(hinge_z, 179.0f);
hinge_y = min_def(hinge_y, 179.0f);
hinge_z = min_def(hinge_z, 179.0f);
hinge_y = hinge_y * DEG_TO_RAD_FLOAT;
hinge_z = hinge_z * DEG_TO_RAD_FLOAT;
RobOsageNode* i_begin = nodes.data() + 1;
@@ -1716,8 +1715,8 @@ void RobOsage::SetOsagePlayData(mat4* parent_mat,
for (RobOsageNode* j = j_begin; j != j_end; j++) {
float_t rot_y = j->field_1B0.field_0.rotation.y;
float_t rot_z = j->field_1B0.field_0.rotation.z;
rot_y = clamp(rot_y, (float_t)-M_PI, (float_t)M_PI);
rot_z = clamp(rot_z, (float_t)-M_PI, (float_t)M_PI);
rot_y = clamp_def(rot_y, (float_t)-M_PI, (float_t)M_PI);
rot_z = clamp_def(rot_z, (float_t)-M_PI, (float_t)M_PI);
mat4_rotate_z_mult(&v85, rot_z, &v85);
mat4_rotate_y_mult(&v85, rot_y, &v85);
j->bone_node_ptr->exp_data.parent_scale = parent_scale;
@@ -1920,7 +1919,7 @@ void ExOsageBlock::Field_50() {
rob.ColiSet(mats);
sub_14047C770(&rob, parent_bone_node->ex_data_mat, &parent_scale, step, 1);
float_t step = 0.5f * this->step;
this->step = max(step, 1.0f);
this->step = max_def(step, 1.0f);
}
void ExOsageBlock::Field_58() {
@@ -2288,11 +2287,11 @@ void ExConstraintBlock::sub_1401EB410(mat4* mat, vec3* a2, vec3* target_offset)
float_t v18;
vec3_dot(v3, v4, v18);
v18 = clamp(v18, -1.0f, 1.0f);
v18 = clamp_def(v18, -1.0f, 1.0f);
float_t v19 = 1.0f - v18;
float_t v20 = 1.0f - v18 * v18;
v20 = sqrtf(clamp(v20, 0.0f, 1.0f));
v20 = sqrtf(clamp_def(v20, 0.0f, 1.0f));
sub_1405F10D0(mat, &v13, v18, v20);
}
@@ -2440,7 +2439,7 @@ void ExExpressionBlock::InitData(rob_chara_item_equip_object* itm_eq_obj,
std::string value_type;
expression = str_utils_get_next_string(expression, value_type, ' ');
if (!value_type.size() || !memcmp(value_type.c_str(), "error",
min(value_type.size(), 5)) && value_type.size() == 5)
min_def(value_type.size(), 5)) && value_type.size() == 5)
break;
if (value_type[0] == 'n') {
@@ -2616,7 +2615,7 @@ void skin_param_osage_root_parse(void* kv, const char* name,
float_t air_res = 0.0f;
if (_kv->read("air_res", air_res))
skp_root.air_res = min(air_res, 0.9f);
skp_root.air_res = min_def(air_res, 0.9f);
float_t rot_y = 0.0f;
float_t rot_z = 0.0f;
@@ -3016,11 +3015,11 @@ static float_t exp_lt(float_t v1, float_t v2) {
}
static float_t exp_max(float_t v1, float_t v2) {
return max(v1, v2);
return max_def(v1, v2);
}
static float_t exp_min(float_t v1, float_t v2) {
return min(v1, v2);
return min_def(v1, v2);
}
static float_t exp_mul(float_t v1, float_t v2) {
@@ -4029,7 +4028,7 @@ static int32_t sub_140483EA0(vec3* a1, vec3* a2, osage_coli* a3, float_t radius)
vec3_dot(v63, a3->bone_pos_diff, v36);
v36 *= v25;
float_t v37 = v36 * v36;
v37 = min(v37, 1.0f);
v37 = min_def(v37, 1.0f);
v22 *= 0.5f;
float_t v38 = v22 * v22 - v61;
if (v38 < 0.0f)
@@ -4468,7 +4467,7 @@ static void sub_140482100(struc_476* a1, opd_blend_data* a2, struc_477* a3) {
}
static void sub_140482DF0(struc_477* dst, struc_477* src0, struc_477* src1, float_t blend) {
dst->length = lerp(src0->length, src1->length, blend);
dst->length = lerp_def(src0->length, src1->length, blend);
vec3_lerp_scalar(src0->rotation, src1->rotation, dst->rotation, blend);
}
src/CRE/rob/rob.cpp
+145 -119
View File
@@ -14,7 +14,7 @@
#include "../random.hpp"
#include "../pv_expression.hpp"
#include "../stage.hpp"
#include "../timer.hpp"
#include "../waitable_timer.hpp"
struct MotFile {
motion_set_info* mot_set_info;
@@ -249,6 +249,7 @@ public:
ReqData();
ReqData(::chara_index chara_index, int32_t count);
virtual ~ReqData();
virtual void Reset();
};
@@ -259,6 +260,7 @@ public:
ReqDataObj();
ReqDataObj(::chara_index chara_index, int32_t count);
virtual ~ReqDataObj() override;
virtual void Reset() override;
};
@@ -845,7 +847,6 @@ static void osage_play_data_manager_get_opd_file_data(object_info obj_info,
static bool pv_osage_manager_array_get_disp(int32_t* chara_id);
static PvOsageManager* pv_osage_manager_array_get(int32_t chara_id);
static void pv_osage_manager_array_set_not_reset_true();
static int pv_data_set_motion_quicksort_compare_func(void const* src1, void const* src2);
@@ -2219,7 +2220,7 @@ void rob_free() {
rob_chara_pv_data_array = 0;
}
free(rob_cmn_mottbl_data);
free_def(rob_cmn_mottbl_data);
if (rob_thread_handler) {
delete rob_thread_handler;
@@ -3197,15 +3198,21 @@ static void rob_chara_set_face_motion(rob_chara* rob_chr,
static void rob_chara_set_hand_l_motion(rob_chara* rob_chr,
RobHandMotion* motion, int32_t type, motion_database* mot_db) {
if (type == 2)
if (type == 2) {
rob_chr->data.motion.field_3B0.hand_l.data = motion->data;
else if (type == 1)
if (!(rob_chr->data.motion.field_29 & 0x08) || (rob_chr->data.motion.field_2A & 0x04))
return;
}
else if (type == 1) {
rob_chr->data.motion.hand_r.data = motion->data;
if ((rob_chr->data.motion.field_29 & 0x08) || !(rob_chr->data.motion.field_2A & 0x04))
return;
}
else {
rob_chr->data.motion.field_150.hand_l.data = motion->data;
else
rob_chr->data.motion.hand_l.data = motion->data;
if (!(rob_chr->data.motion.field_29 & 0x08) || rob_chr->data.motion.field_2A & 0x04)
return;
if ((rob_chr->data.motion.field_29 & 0x08) || (rob_chr->data.motion.field_2A & 0x04))
return;
}
rob_chara_bone_data_load_hand_l_motion(rob_chr->bone_data, motion->data.motion_id, mot_db);
rob_chara_bone_data_set_hand_l_frame(rob_chr->bone_data, motion->data.frame);
@@ -3216,15 +3223,21 @@ static void rob_chara_set_hand_l_motion(rob_chara* rob_chr,
static void rob_chara_set_hand_r_motion(rob_chara* rob_chr,
RobHandMotion* motion, int32_t type, motion_database* mot_db) {
if (type == 2)
if (type == 2) {
rob_chr->data.motion.field_3B0.hand_r.data = motion->data;
else if (type == 1)
rob_chr->data.motion.field_150.hand_r.data = motion->data;
else
if (!(rob_chr->data.motion.field_29 & 0x10) || (rob_chr->data.motion.field_2A & 0x08))
return;
}
else if (type == 1) {
rob_chr->data.motion.hand_r.data = motion->data;
if (!(rob_chr->data.motion.field_29 & 0x10) || rob_chr->data.motion.field_2A & 0x08)
return;
if ((rob_chr->data.motion.field_29 & 0x10) || !(rob_chr->data.motion.field_2A & 0x08))
return;
}
else {
rob_chr->data.motion.field_150.hand_r.data = motion->data;
if ((rob_chr->data.motion.field_29 & 0x10) || (rob_chr->data.motion.field_2A & 0x08))
return;
}
rob_chara_bone_data_load_hand_r_motion(rob_chr->bone_data, motion->data.motion_id, mot_db);
rob_chara_bone_data_set_hand_r_frame(rob_chr->bone_data, motion->data.frame);
@@ -3468,10 +3481,10 @@ void rob_chara::set_eyes_mottbl_motion(int32_t type,
}
static void sub_140553970(rob_chara* rob_chr, object_info a2, int32_t type) {
if (type == 1)
rob_chr->data.motion.field_150.head_object = a2;
else
if (type != 1 && type == 2)
rob_chr->data.motion.field_3B0.head_object = a2;
else
rob_chr->data.motion.field_150.head_object = a2;
}
void rob_chara::set_face_mottbl_motion(int32_t type,
@@ -4224,8 +4237,8 @@ static void bone_data_mult_ik(bone_data* a1, int32_t skeleton_select) {
rot_cos = (v28 + ik_segment_length) / (2.0f * v10);
rot_2nd_cos = (v28 - ik_segment_length) / (2.0f * ik_2nd_segment_length);
rot_cos = clamp(rot_cos, -1.0f, 1.0f);
rot_2nd_cos = clamp(rot_2nd_cos, -1.0f, 1.0f);
rot_cos = clamp_def(rot_cos, -1.0f, 1.0f);
rot_2nd_cos = clamp_def(rot_2nd_cos, -1.0f, 1.0f);
rot_sin = sqrtf(1.0f - rot_cos * rot_cos);
rot_2nd_sin = sqrtf(1.0f - rot_2nd_cos * rot_2nd_cos);
@@ -6192,7 +6205,7 @@ static void motion_blend_mot_set_blend(motion_blend_mot* a1,
case MOTION_BLEND_COMBINE:
a1->blend = &a1->combine;
a1->combine.Reset();
a1->combine.blend = clamp(blend, 0.0f, 1.0f);
a1->combine.blend = clamp_def(blend, 0.0f, 1.0f);
break;
}
}
@@ -6239,11 +6252,6 @@ static PvOsageManager* pv_osage_manager_array_get(int32_t chara_id) {
return &pv_osage_manager_array[chara_id];
}
static void pv_osage_manager_array_set_not_reset_true() {
for (int32_t i = 0; i < ROB_CHARA_COUNT; i++)
pv_osage_manager_array_get(i)->SetNotReset(true);
}
static int pv_data_set_motion_quicksort_compare_func(void const* src1, void const* src2) {
pv_data_set_motion* pv1 = (pv_data_set_motion*)src1;
pv_data_set_motion* pv2 = (pv_data_set_motion*)src2;
@@ -6375,13 +6383,13 @@ void rob_chara_data_adjust_ctrl(rob_chara* rob_chr, rob_chara_data_adjust* adjus
float_t blend = (adjust->transition_frame + 1.0f) / (adjust->force_duration + 1.0f);
vec3_lerp_scalar(adjust_prev->curr_external_force,
adjust->curr_external_force, adjust->curr_external_force, blend);
adjust->curr_force = lerp(adjust_prev->curr_force, adjust->curr_force, blend);
adjust->curr_force = lerp_def(adjust_prev->curr_force, adjust->curr_force, blend);
}
if (adjust->strength_transition > adjust->transition_frame
&& fabsf(adjust->strength_transition - adjust->transition_frame) > 0.000001f) {
float_t blend = (adjust->transition_frame + 1.0f) / (adjust->strength_transition + 1.0f);
adjust->curr_strength = lerp(adjust_prev->curr_strength, adjust->curr_strength, blend);
adjust->curr_strength = lerp_def(adjust_prev->curr_strength, adjust->curr_strength, blend);
}
else if (!transition_frame_step)
return;
@@ -7831,7 +7839,6 @@ static void sub_140407280(struc_258* a1, std::vector<bone_data>* a2, mat4* mat,
vec3_normalize(v67, v67);
vec3_mult_scalar(v67, v28, v68);
float_t v39;
vec2_length(*(vec2*)&v67, v39);
@@ -8300,7 +8307,6 @@ static void rob_chara_set_hand_adjust(rob_chara* rob_chr,
switch (adjust->type) {
case ROB_CHARA_DATA_HAND_ADJUST_NORMAL:
case 15:
adjust->scale = chara_size_table_get_value(1);
break;
case ROB_CHARA_DATA_HAND_ADJUST_SHORT:
@@ -8310,10 +8316,10 @@ static void rob_chara_set_hand_adjust(rob_chara* rob_chr,
adjust->scale = chara_size_table_get_value(0);
break;
case ROB_CHARA_DATA_HAND_ADJUST_MIN:
adjust->scale = min(opposite_chara_scale, chara_scale);
adjust->scale = min_def(opposite_chara_scale, chara_scale);
break;
case ROB_CHARA_DATA_HAND_ADJUST_MAX:
adjust->scale = max(opposite_chara_scale, chara_scale);
adjust->scale = max_def(opposite_chara_scale, chara_scale);
break;
case ROB_CHARA_DATA_HAND_ADJUST_OPPOSITE_CHARA:
adjust->scale = opposite_chara_scale;
@@ -8355,7 +8361,7 @@ static void rob_chara_set_hand_adjust(rob_chara* rob_chr,
if (fabsf(prev_scale - scale * adjust->scale_blend) <= 0.000001f || adjust->duration <= adjust->current_time
|| fabsf(adjust->duration - adjust->current_time) <= 0.000001f) {
adjust->current_scale = lerp(prev_scale, scale, adjust->scale_blend);
adjust->current_scale = lerp_def(prev_scale, scale, adjust->scale_blend);
if (fabsf(adjust->current_scale - chara_scale) <= 0.000001f) {
adjust->current_scale = chara_scale;
adjust->enable = false;
@@ -8363,7 +8369,7 @@ static void rob_chara_set_hand_adjust(rob_chara* rob_chr,
}
else {
float_t t = (adjust->current_time + 1.0f) / (adjust->duration + 1.0f);
adjust->current_scale = lerp(prev_scale, scale, t * adjust->scale_blend);
adjust->current_scale = lerp_def(prev_scale, scale, t * adjust->scale_blend);
adjust->current_time += rob_chr->data.motion.step_data.frame;
}
}
@@ -8640,7 +8646,7 @@ static bool sub_14053B580(rob_chara* rob_chr, int32_t a2) {
float_t v32 = v0.field_8 - v30 + 1.0f;
if (fabsf(v32) > 0.000001f) {
v31 = (v0.field_8 - v29) / v32;
v31 = clamp(v31, 0.0f, 1.0f);
v31 = clamp_def(v31, 0.0f, 1.0f);
}
int32_t v33 = v0.field_0;
@@ -8786,7 +8792,7 @@ static void sub_1403FA040(vec3* a1, float_t a2, mat4* a3, float_t ymin,
if (fabsf(v16.z) > 0.000001f) {
vec3_normalize(v16, v16);
vec3_mult_scalar(v16, a2, v16);
v16.z = clamp(v16.z, zmin, zmax);
v16.z = clamp_def(v16.z, zmin, zmax);
}
goto LABEL_66;
}
@@ -8838,7 +8844,7 @@ static void sub_1403FA040(vec3* a1, float_t a2, mat4* a3, float_t ymin,
if (fabsf(v16.y) > 0.000001f) {
vec3_normalize(v16, v16);
vec3_mult_scalar(v16, a2, v16);
v16.y = clamp(v16.y, ymin, ymax);
v16.y = clamp_def(v16.y, ymin, ymax);
}
goto LABEL_66;
}
@@ -9141,7 +9147,7 @@ static void sub_140406920(vec3* a1, bone_data* a2, bone_data* a3, float_t heel_h
v12 = 0.0f;
a2->ik_target.x = v18.x;
a2->ik_target.y = v18.y + lerp(v12, v11, a5->z);
a2->ik_target.y = v18.y + lerp_def(v12, v11, a5->z);
a2->ik_target.z = v18.z;
}
@@ -9723,10 +9729,11 @@ static void rob_chara_bone_data_interpolate(rob_chara_bone_data* rob_bone_data)
}
static void rob_chara_bone_data_motion_blend_mot_free(rob_chara_bone_data* rob_bone_data) {
rob_bone_data->motion_indices.clear();
rob_chara_bone_data_motion_blend_mot_list_free(rob_bone_data, 0);
for (motion_blend_mot*& i : rob_bone_data->motions)
delete i;
rob_bone_data->motions.clear();
rob_bone_data->motion_indices.clear();
}
static void rob_chara_bone_data_motion_blend_mot_init(rob_chara_bone_data* rob_bone_data) {
@@ -11925,7 +11932,7 @@ static void rob_chara_set_pv_data(rob_chara* rob_chr, int8_t chara_id,
}
static void rob_cmn_mottbl_read(void* a1, const void* data, size_t size) {
free(rob_cmn_mottbl_data);
free_def(rob_cmn_mottbl_data);
farc f;
f.read(data, size, true);
@@ -12042,6 +12049,11 @@ bool pv_osage_manager_array_get_disp() {
return disp;
}
void pv_osage_manager_array_set_not_reset_true() {
for (int32_t i = 0; i < ROB_CHARA_COUNT; i++)
pv_osage_manager_array_get(i)->SetNotReset(true);
}
void pv_osage_manager_array_set_pv_id(int32_t chara_id, int32_t pv_id, bool reset) {
pv_osage_manager_array_get(chara_id)->SetPvId(pv_id, chara_id, reset);
}
@@ -12350,11 +12362,11 @@ void MotionBlendCross::Blend(bone_data* a2, bone_data* a3) {
break;
case BONE_DATABASE_BONE_POSITION_ROTATION:
if (field_21) {
a2->trans.x = lerp(a3->trans.x, a2->trans.x, blend);
a2->trans.z = lerp(a3->trans.z, a2->trans.z, blend);
a2->trans.x = lerp_def(a3->trans.x, a2->trans.x, blend);
a2->trans.z = lerp_def(a3->trans.z, a2->trans.z, blend);
}
if (field_20)
a2->trans.y = lerp(a3->trans.y, a2->trans.y, blend);
a2->trans.y = lerp_def(a3->trans.y, a2->trans.y, blend);
break;
case BONE_DATABASE_BONE_HEAD_IK_ROTATION:
if (a2->motion_bone_index == MOTION_BONE_CL_MUNE) {
@@ -12520,11 +12532,11 @@ void MotionBlendFreeze::Blend(bone_data* a2, bone_data* a3) {
break;
case BONE_DATABASE_BONE_POSITION_ROTATION:
if (field_21) {
a2->trans.x = lerp(a2->trans_prev[field_24].x, a2->trans.x, blend);
a2->trans.z = lerp(a2->trans_prev[field_24].z, a2->trans.z, blend);
a2->trans.x = lerp_def(a2->trans_prev[field_24].x, a2->trans.x, blend);
a2->trans.z = lerp_def(a2->trans_prev[field_24].z, a2->trans.z, blend);
}
if (field_20)
a2->trans.y = lerp(a2->trans_prev[field_24].y, a2->trans.y, blend);
a2->trans.y = lerp_def(a2->trans_prev[field_24].y, a2->trans.y, blend);
break;
case BONE_DATABASE_BONE_HEAD_IK_ROTATION:
if (a2->motion_bone_index == MOTION_BONE_CL_MUNE) {
@@ -13248,7 +13260,7 @@ void rob_chara_item_equip_object::reset_external_force() {
void rob_chara_item_equip_object::set_alpha_draw_task_flags(float_t alpha, int32_t flags) {
draw_task_flags = (::draw_task_flags)flags;
this->alpha = clamp(alpha, 0.0f, 1.0f);
this->alpha = clamp_def(alpha, 0.0f, 1.0f);
}
bool rob_chara_item_equip_object::set_boc(
@@ -14412,6 +14424,21 @@ int32_t expression_id_to_mottbl_index(int32_t expression_id) {
return 6;
}
/*
195 CMN_HAND_OPEN 0
196 CMN_HAND_CLOSE 1
194 CMN_HAND_NORMAL 2
197 CMN_HAND_PEACE 3
201 CMN_HAND_NEGI 4
198 CMN_HAND_MIC 5
199 CMN_HAND_ONE 6
202 CMN_HAND_SIZEN 7
203 CMN_HAND_PICK 8
192 (null) 9
200 CMN_HAND_THREE 10
204 CMN_HAND_MIC 11,12,13
193 CMN_HAND_RESET 14*/
int32_t hand_anim_id_to_mottbl_index(int32_t hand_anim_id) {
static const int32_t hand_anim_id_to_mottbl_index_table[] = {
195, 196, 194, 197, 201, 198, 199, 202,
@@ -15562,9 +15589,7 @@ bool OpdMaker::InitThread(rob_chara* rob_chr, std::vector<int32_t>* motion_ids,
bool OpdMaker::IsWaiting() {
std::unique_lock<std::mutex> u_lock(waiting_mtx);
bool ret = waiting;
u_lock.unlock();
return ret;
return waiting;
}
void OpdMaker::Reset() {
@@ -15594,20 +15619,16 @@ bool OpdMaker::SetOsagePlayInitData(int32_t motion_id) {
void OpdMaker::SetWaiting(bool value) {
std::unique_lock<std::mutex> u_lock(waiting_mtx);
waiting = value;
u_lock.unlock();
}
void OpdMaker::sub_140475AE0() {
std::unique_lock<std::mutex> u_lock(field_40);
field_18 = true;
u_lock.unlock();
}
bool OpdMaker::sub_140478330() {
std::unique_lock<std::mutex> u_lock(field_40);
bool ret = field_18;
u_lock.unlock();
return ret;
return field_18;
}
void OpdMaker::ThreadMain(OpdMaker* opd_maker) {
@@ -16191,15 +16212,21 @@ PvOsageManager::PvOsageManager() : state(), chara_id(), reset(), field_74(),
motion_index(), pv(), thread(), disp(), not_reset(), exit(), field_D4() {
Reset();
std::unique_lock<std::mutex> u_disp_mtx_lock(disp_mtx);
disp = false;
u_disp_mtx_lock.unlock();
std::unique_lock<std::mutex> u_not_reset_mtx_lock(not_reset_mtx);
not_reset = false;
u_not_reset_mtx_lock.unlock();
std::unique_lock<std::mutex> u_exit_mtx_lock(exit_mtx);
exit = false;
u_exit_mtx_lock.unlock();
{
std::unique_lock<std::mutex> u_lock(disp_mtx);
disp = false;
}
{
std::unique_lock<std::mutex> u_lock(not_reset_mtx);
not_reset = false;
}
{
std::unique_lock<std::mutex> u_lock(exit_mtx);
exit = false;
}
thread = new std::thread(PvOsageManager::ThreadMain, this);
if (thread) {
@@ -16210,9 +16237,11 @@ motion_index(), pv(), thread(), disp(), not_reset(), exit(), field_D4() {
}
PvOsageManager::~PvOsageManager() {
std::unique_lock<std::mutex> u_lock(exit_mtx);
exit = true;
u_lock.unlock();
{
std::unique_lock<std::mutex> u_lock(exit_mtx);
exit = true;
}
cnd.notify_one();
thread->join();
delete thread;
@@ -16275,45 +16304,38 @@ void PvOsageManager::AddMotionFrameResetData(int32_t stage_index, int32_t motion
}
bool PvOsageManager::CheckResetFrameNotFound(int32_t motion_id, float_t frame) {
return reset_frames_list.find(frame) == reset_frames_list.end();
return reset_frames_list.find(frame) == reset_frames_list.end();
}
bool PvOsageManager::GetDisp() {
std::unique_lock<std::mutex> u_lock(disp_mtx);
bool disp = this->disp;
u_lock.unlock();
return disp;
}
bool PvOsageManager::GetNotReset() {
std::unique_lock<std::mutex> u_lock(not_reset_mtx);
bool not_reset = this->not_reset;
u_lock.unlock();
return not_reset;
}
void PvOsageManager::SetDisp(bool value) {
std::unique_lock<std::mutex> u_lock(disp_mtx);
disp = value;
u_lock.unlock();
}
void PvOsageManager::SetNotReset(bool value) {
std::unique_lock<std::mutex> u_lock(not_reset_mtx);
not_reset = value;
u_lock.unlock();
}
void PvOsageManager::SetPvId(int32_t pv_id, int32_t chara_id, bool reset) {
if (!pv_set_motion.size())
return;
HANDLE timer = timer_handle_init();
waitable_timer timer;
while (GetDisp()) {
SetNotReset(true);
timer_handle_sleep(timer, 1.0);
timer.sleep(1);
}
timer_handle_dispose(timer);
SetDisp(true);
SetNotReset(false);
@@ -16329,7 +16351,7 @@ void PvOsageManager::SetPvId(int32_t pv_id, int32_t chara_id, bool reset) {
}
void PvOsageManager::SetPvSetMotion(std::vector<pv_data_set_motion>& set_motion) {
pv_set_motion = set_motion;
pv_set_motion.assign(set_motion.begin(), set_motion.end());
}
void PvOsageManager::sub_1404F77E0() {
@@ -16343,6 +16365,7 @@ void PvOsageManager::sub_1404F77E0() {
&& i->frame_stage_index.first == i_next->frame_stage_index.first) {
memmove(i, i_next, sizeof(pv_data_set_motion) * (i_end - i_next));
pv_set_motion.pop_back();
i_end--;
continue;
}
else {
@@ -16406,18 +16429,21 @@ void PvOsageManager::Reset() {
void PvOsageManager::sub_1404F82F0() {
do {
std::unique_lock<std::mutex> u_not_reset_lock(not_reset_mtx);
bool not_reset = this->not_reset;
u_not_reset_lock.unlock();
if (not_reset)
break;
{
std::unique_lock<std::mutex> u_lock(not_reset_mtx);
if (not_reset)
break;
}
sub_1404F8AA0();
} while (sub_1404F7AF0());
std::unique_lock<std::mutex> u_not_reset_lock(not_reset_mtx);
bool not_reset = this->not_reset;
u_not_reset_lock.unlock();
bool not_reset = false;
{
std::unique_lock<std::mutex> u_lock(not_reset_mtx);
not_reset = this->not_reset;
}
sub_1404F7BD0(not_reset);
}
@@ -16618,26 +16644,29 @@ void PvOsageManager::ThreadMain(PvOsageManager* pv_osg_mgr) {
std::unique_lock<std::mutex> u_lock(pv_osg_mgr->mtx);
while (true) {
pv_osg_mgr->cnd.wait(u_lock);
std::unique_lock<std::mutex> u_exit_lock(pv_osg_mgr->exit_mtx);
bool exit = pv_osg_mgr->exit;
u_exit_lock.unlock();
if (exit)
break;
{
std::unique_lock<std::mutex> u_lock(pv_osg_mgr->exit_mtx);
if (pv_osg_mgr->exit)
break;
}
pv_osg_mgr->sub_1404F82F0();
std::unique_lock<std::mutex> u_not_reset_lock(pv_osg_mgr->not_reset_mtx);
u_not_reset_lock.unlock();
{
std::unique_lock<std::mutex> u_lock(pv_osg_mgr->not_reset_mtx);
}
std::unique_lock<std::mutex> u_disp_lock(pv_osg_mgr->disp_mtx);
pv_osg_mgr->disp = false;
u_disp_lock.unlock();
{
std::unique_lock<std::mutex> u_lock(pv_osg_mgr->disp_mtx);
pv_osg_mgr->disp = false;
}
}
std::unique_lock<std::mutex> u_disp_lock(pv_osg_mgr->disp_mtx);
pv_osg_mgr->disp = false;
u_disp_lock.unlock();
u_lock.unlock();
{
std::unique_lock<std::mutex> u_lock(pv_osg_mgr->disp_mtx);
pv_osg_mgr->disp = false;
}
}
RobThreadParent::RobThreadParent() : exit(), thread() {
@@ -16650,9 +16679,11 @@ RobThreadParent::RobThreadParent() : exit(), thread() {
}
RobThreadParent::~RobThreadParent() {
std::unique_lock<std::mutex> u_lock(mtx);
exit = true;
u_lock.unlock();
{
std::unique_lock<std::mutex> u_lock(mtx);
exit = true;
}
cnd.notify_one();
thread->join();
delete thread;
@@ -16666,7 +16697,6 @@ void RobThreadParent::AppendRobCharaFunc(rob_chara* rob_chr, void(*rob_chr_func)
thrd.func = rob_chr_func;
AppendRobThread(&thrd);
cnd.notify_one();
u_lock.unlock();
}
void RobThreadHandler::sub_14054E3F0() {
@@ -16677,26 +16707,24 @@ void RobThreadHandler::sub_14054E3F0() {
void RobThreadParent::AppendRobThread(RobThread* thread) {
std::unique_lock<std::mutex> u_lock(threads_mtx);
threads.push_back(*thread);
u_lock.unlock();
}
bool RobThreadParent::CheckThreadsNotNull() {
std::unique_lock<std::mutex> u_lock(threads_mtx);
bool not_null = !!threads.size();
u_lock.unlock();
return not_null;
return !!threads.size();
}
void RobThreadParent::sub_14054E0D0() {
std::unique_lock<std::mutex> u_lock(threads_mtx);
threads.pop_front();
bool v5 = this->threads.size() == 0;
u_lock.unlock();
bool threads_null = false;
{
std::unique_lock<std::mutex> u_lock(threads_mtx);
threads.pop_front();
threads_null = threads.size() == 0;
}
if (v5) {
if (threads_null) {
std::unique_lock<std::mutex> u_lock(field_28);
field_30.notify_one();
u_lock.unlock();
}
}
@@ -16704,7 +16732,6 @@ void RobThreadParent::sub_14054E370() {
std::unique_lock<std::mutex> u_lock(field_28);
if (CheckThreadsNotNull())
field_30.wait(u_lock);
u_lock.unlock();
}
void RobThreadParent::ThreadMain(RobThreadParent* rob_thrd_parent) {
@@ -16719,7 +16746,6 @@ void RobThreadParent::ThreadMain(RobThreadParent* rob_thrd_parent) {
else
rob_thrd_parent->cnd.wait(u_lock);
}
u_lock.unlock();
}
RobThreadHandler::RobThreadHandler() {
@@ -18063,7 +18089,7 @@ static void sub_1404156B0(mot_play_data* a1) {
switch (frame_data->field_1C) {
case 0:
default:
frame_data->frame = min(frame_data->frame, frame_data->frame_count);
frame_data->frame = min_def(frame_data->frame, frame_data->frame_count);
break;
case 1: {
if (frame_data->field_24 >= 0.0f && frame_data->field_24 <= last_frame)
src/CRE/rob/rob.hpp
+1
View File
@@ -3273,6 +3273,7 @@ extern void rob_chara_array_set_alpha_draw_task_flags(int32_t chara_id, float_t
extern bool rob_chara_pv_data_array_check_chara_id(int32_t chara_id);
extern bool pv_osage_manager_array_get_disp();
extern void pv_osage_manager_array_set_not_reset_true();
extern void pv_osage_manager_array_set_pv_id(int32_t chara_id, int32_t pv_id, bool reset);
extern void pv_osage_manager_array_set_pv_set_motion(
int32_t chara_id, std::vector<pv_data_set_motion>& set_motion);
src/CRE/shader.cpp
+69 -98
View File
@@ -4,6 +4,7 @@
*/
#include "shader.hpp"
#include "../KKdLib/io/file_stream.hpp"
#include "../KKdLib/io/path.hpp"
#include "../KKdLib/hash.hpp"
#include "../KKdLib/str_utils.hpp"
@@ -100,7 +101,7 @@ env_update_data(), buffer_update_data(), state_ubo(), state_matrix_ubo(), env_ub
}
int32_t shader::bind(uint32_t sub_index) {
int32_t shader::bind(shader_set_data* set, uint32_t sub_index) {
int32_t sub_shader_index = 0;
if (num_sub < 1)
return -1;
@@ -125,12 +126,12 @@ int32_t shader::bind(uint32_t sub_index) {
int32_t i = 0;
for (i = 0; i < num_uniform && i < 16; i++) {
int32_t unival_max = use_permut[i]
? max(vp_unival_max[i], fp_unival_max[i]) : 0;
unival += unival_curr * min(uniform_value[(int32_t)use_uniform[i]], unival_max);
? max_def(vp_unival_max[i], fp_unival_max[i]) : 0;
unival += unival_curr * min_def(uniform_value[(int32_t)use_uniform[i]], unival_max);
unival_curr *= unival_max + 1;
int32_t unival_max_glsl = max(vp_unival_max[i], fp_unival_max[i]);
uniform_val[i] = min(uniform_value[use_uniform[i]], unival_max_glsl);
int32_t unival_max_glsl = max_def(vp_unival_max[i], fp_unival_max[i]);
uniform_val[i] = min_def(uniform_value[use_uniform[i]], unival_max_glsl);
}
for (; i < 16; i++)
@@ -260,8 +261,8 @@ void shader_set_data::load(farc* f, bool ignore_cache, bool not_load_cache,
}
if (!vert_data || !frag_data) {
free(vert_data);
free(frag_data);
free_def(vert_data);
free_def(frag_data);
continue;
}
@@ -308,7 +309,7 @@ void shader_set_data::load(farc* f, bool ignore_cache, bool not_load_cache,
const int32_t* fp_unival_max = sub_table->fp_unival_max;
for (size_t k = 0; k < num_uniform; k++) {
size_t unival_max = shader->use_permut[k]
? max(vp_unival_max[k], fp_unival_max[k]) : 0;
? max_def(vp_unival_max[k], fp_unival_max[k]) : 0;
unival_count += unival_curr * unival_max;
unival_curr *= unival_max + 1;
}
@@ -339,16 +340,16 @@ void shader_set_data::load(farc* f, bool ignore_cache, bool not_load_cache,
for (size_t k = 0; k < unival_count; k++) {
for (size_t l = 0, m = k; l < num_uniform; l++) {
size_t unival_max = (size_t)(shader->use_permut[l]
? max(vp_unival_max[l], fp_unival_max[l]) : 0) + 1;
vec_vert[l] = (uint32_t)(min(m % unival_max, vp_unival_max[l]));
? max_def(vp_unival_max[l], fp_unival_max[l]) : 0) + 1;
vec_vert[l] = (uint32_t)(min_def(m % unival_max, vp_unival_max[l]));
m /= unival_max;
vert_buf[vert_buf_pos + l] = (char)('0' + vec_vert[l]);
}
for (size_t l = 0, m = k; l < num_uniform; l++) {
size_t unival_max = (size_t)(shader->use_permut[l]
? max(vp_unival_max[l], fp_unival_max[l]) : 0) + 1;
vec_frag[l] = (uint32_t)(min(m % unival_max, fp_unival_max[l]));
? max_def(vp_unival_max[l], fp_unival_max[l]) : 0) + 1;
vec_frag[l] = (uint32_t)(min_def(m % unival_max, fp_unival_max[l]));
m /= unival_max;
frag_buf[frag_buf_pos + l] = (char)('0' + vec_frag[l]);
}
@@ -436,7 +437,7 @@ void shader_set_data::load(farc* f, bool ignore_cache, bool not_load_cache,
shader_cache_file = &shader_cache_farc.files.back();
}
else
free(shader_cache_file->data);
free_def(shader_cache_file->data);
size_t bin_count = program_data_binary.size();
size_t bin_size = sizeof(uint64_t) * 2 + bin_count * sizeof(program_binary);
@@ -459,14 +460,14 @@ void shader_set_data::load(farc* f, bool ignore_cache, bool not_load_cache,
bin_data_base += sizeof(program_binary);
bin_data += k.length;
void* binary = (void*)k.binary;
free(binary);
free_def(binary);
k.binary = 0;
bin++;
}
}
free(vert_data);
free(frag_data);
free_def(vert_data);
free_def(frag_data);
program_data_binary.clear();
}
vec_vert.clear();
@@ -478,9 +479,9 @@ void shader_set_data::load(farc* f, bool ignore_cache, bool not_load_cache,
break;
}
}
free(binary);
free(temp_vert);
free(temp_frag);
free_def(binary);
free_def(temp_vert);
free_def(temp_frag);
if (shader_cache_changed)
shader_cache_farc.write(temp_buf, FARC_COMPRESS_FArC, false);
@@ -514,7 +515,7 @@ void shader_set_data::set(uint32_t index) {
if (shader->bind_func)
shader->bind_func(this, shader);
else
shader->bind(shader->sub[0].sub_index);
shader->bind(this, shader->sub[0].sub_index);
gl_state_bind_uniform_buffer_range(0, data.state_ubo, 0, sizeof(data.state));
gl_state_bind_uniform_buffer_range(1, data.state_matrix_ubo, 0, sizeof(data.state_matrix));
gl_state_bind_uniform_buffer_range(2, data.env_ubo, 0, sizeof(data.env));
@@ -544,7 +545,7 @@ void shader_set_data::unload() {
const int32_t* fp_unival_max = sub->fp_unival_max;
for (size_t k = 0; k < num_uniform; k++) {
size_t unival_max = shader->use_permut[k]
? max(vp_unival_max[k], fp_unival_max[k]) : 0;
? max_def(vp_unival_max[k], fp_unival_max[k]) : 0;
unival_count += unival_curr * unival_max;
unival_curr *= unival_max + 1;
}
@@ -552,17 +553,17 @@ void shader_set_data::unload() {
if (sub->program)
for (size_t k = 0; k < unival_count; k++)
glDeleteProgram(sub->program[k]);
free(sub->program);
free_def(sub->program);
}
else {
if (sub->program)
glDeleteProgram(sub->program[0]);
free(sub->program);
free_def(sub->program);
}
}
free(shader->sub);
free_def(shader->sub);
}
free(shaders);
free_def(shaders);
}
void shader_set_data::buffer_get(size_t index, vec4& data) {
@@ -1187,12 +1188,8 @@ void shader_set_data::state_light_set_ambient(size_t index, float_t x, float_t y
this->data.state.light[index].ambient = data;
this->data.state_update_data = true;
vec4 lightprod_front;
vec4 lightprod_back;
vec4_mult(this->data.state.light[index].ambient,
this->data.state.material[0].ambient, lightprod_front);
vec4_mult(this->data.state.light[index].ambient,
this->data.state.material[1].ambient, lightprod_back);
vec4 lightprod_front = this->data.state.light[index].ambient * this->data.state.material[0].ambient;
vec4 lightprod_back = this->data.state.light[index].ambient * this->data.state.material[1].ambient;
state_lightprod_set_ambient(false, index, lightprod_front);
state_lightprod_set_ambient(true, index, lightprod_back);
}
@@ -1207,12 +1204,8 @@ void shader_set_data::state_light_set_ambient(size_t index, const vec4& data) {
this->data.state.light[index].ambient = data;
this->data.state_update_data = true;
vec4 lightprod_front;
vec4 lightprod_back;
vec4_mult(this->data.state.light[index].ambient,
this->data.state.material[0].ambient, lightprod_front);
vec4_mult(this->data.state.light[index].ambient,
this->data.state.material[1].ambient, lightprod_back);
vec4 lightprod_front = this->data.state.light[index].ambient * this->data.state.material[0].ambient;
vec4 lightprod_back = this->data.state.light[index].ambient * this->data.state.material[1].ambient;
state_lightprod_set_ambient(false, index, lightprod_front);
state_lightprod_set_ambient(true, index, lightprod_back);
}
@@ -1228,12 +1221,8 @@ void shader_set_data::state_light_set_diffuse(size_t index, float_t x, float_t y
this->data.state.light[index].diffuse = data;
this->data.state_update_data = true;
vec4 lightprod_front;
vec4 lightprod_back;
vec4_mult(this->data.state.light[index].diffuse,
this->data.state.material[0].diffuse, lightprod_front);
vec4_mult(this->data.state.light[index].diffuse,
this->data.state.material[1].diffuse, lightprod_back);
vec4 lightprod_front = this->data.state.light[index].diffuse * this->data.state.material[0].diffuse;
vec4 lightprod_back = this->data.state.light[index].diffuse * this->data.state.material[1].diffuse;
state_lightprod_set_diffuse(false, index, lightprod_front);
state_lightprod_set_diffuse(true, index, lightprod_back);
}
@@ -1248,12 +1237,8 @@ void shader_set_data::state_light_set_diffuse(size_t index, const vec4& data) {
this->data.state.light[index].diffuse = data;
this->data.state_update_data = true;
vec4 lightprod_front;
vec4 lightprod_back;
vec4_mult(this->data.state.light[index].diffuse,
this->data.state.material[0].diffuse, lightprod_front);
vec4_mult(this->data.state.light[index].diffuse,
this->data.state.material[1].diffuse, lightprod_back);
vec4 lightprod_front = this->data.state.light[index].diffuse * this->data.state.material[0].diffuse;
vec4 lightprod_back = this->data.state.light[index].diffuse * this->data.state.material[1].diffuse;
state_lightprod_set_diffuse(false, index, lightprod_front);
state_lightprod_set_diffuse(true, index, lightprod_back);
}
@@ -1269,12 +1254,8 @@ void shader_set_data::state_light_set_specular(size_t index, float_t x, float_t
this->data.state.light[index].specular = data;
this->data.state_update_data = true;
vec4 lightprod_front;
vec4 lightprod_back;
vec4_mult(this->data.state.light[index].specular,
this->data.state.material[0].specular, lightprod_front);
vec4_mult(this->data.state.light[index].specular,
this->data.state.material[1].specular, lightprod_back);
vec4 lightprod_front = this->data.state.light[index].specular * this->data.state.material[0].diffuse;
vec4 lightprod_back = this->data.state.light[index].specular * this->data.state.material[1].diffuse;
state_lightprod_set_specular(false, index, lightprod_front);
state_lightprod_set_specular(true, index, lightprod_back);
}
@@ -1289,12 +1270,8 @@ void shader_set_data::state_light_set_specular(size_t index, const vec4& data) {
this->data.state.light[index].specular = data;
this->data.state_update_data = true;
vec4 lightprod_front;
vec4 lightprod_back;
vec4_mult(this->data.state.light[index].specular,
this->data.state.material[0].specular, lightprod_front);
vec4_mult(this->data.state.light[index].specular,
this->data.state.material[1].specular, lightprod_back);
vec4 lightprod_front = this->data.state.light[index].specular * this->data.state.material[0].diffuse;
vec4 lightprod_back = this->data.state.light[index].specular * this->data.state.material[1].diffuse;
state_lightprod_set_specular(false, index, lightprod_front);
state_lightprod_set_specular(true, index, lightprod_back);
}
@@ -1540,9 +1517,8 @@ void shader_set_data::state_material_set_ambient(bool back, float_t x, float_t y
this->data.state_update_data = true;
for (int32_t index = 0; index < SHADER_MAX_LIGHTS; index++) {
vec4 lightprod;
vec4_mult(this->data.state.light[index].ambient,
this->data.state.material[back ? 1 : 0].ambient, lightprod);
vec4 lightprod = this->data.state.light[index].ambient
* this->data.state.material[back ? 1 : 0].ambient;
state_lightprod_set_ambient(back, index, lightprod);
}
}
@@ -1558,9 +1534,8 @@ void shader_set_data::state_material_set_ambient(bool back, const vec4& data) {
this->data.state_update_data = true;
for (int32_t index = 0; index < SHADER_MAX_LIGHTS; index++) {
vec4 lightprod;
vec4_mult(this->data.state.light[index].ambient,
this->data.state.material[back ? 1 : 0].ambient, lightprod);
vec4 lightprod = this->data.state.light[index].ambient
* this->data.state.material[back ? 1 : 0].ambient;
state_lightprod_set_ambient(back, index, lightprod);
}
}
@@ -1575,11 +1550,10 @@ void shader_set_data::state_material_set_diffuse(bool back, float_t x, float_t y
this->data.state.material[back ? 1 : 0].diffuse = data;
this->data.state_update_data = true;
vec4 lightprod;
for (int32_t index = 0; index < SHADER_MAX_LIGHTS; index++) {
vec4_mult(this->data.state.light[index].diffuse,
this->data.state.material[back ? 1 : 0].diffuse, lightprod);
vec4 lightprod = this->data.state.light[index].diffuse
* this->data.state.material[back ? 1 : 0].diffuse;
state_lightprod_set_diffuse(back, index, lightprod);
}
}
@@ -1595,9 +1569,8 @@ void shader_set_data::state_material_set_diffuse(bool back, const vec4& data) {
this->data.state_update_data = true;
for (int32_t index = 0; index < SHADER_MAX_LIGHTS; index++) {
vec4 lightprod;
vec4_mult(this->data.state.light[index].diffuse,
this->data.state.material[back ? 1 : 0].diffuse, lightprod);
vec4 lightprod = this->data.state.light[index].diffuse
* this->data.state.material[back ? 1 : 0].diffuse;
state_lightprod_set_diffuse(back, index, lightprod);
}
}
@@ -1614,9 +1587,8 @@ void shader_set_data::state_material_set_specular(bool back, float_t x, float_t
this->data.state_update_data = true;
for (int32_t index = 0; index < SHADER_MAX_LIGHTS; index++) {
vec4 lightprod;
vec4_mult(this->data.state.light[index].specular,
this->data.state.material[back ? 1 : 0].specular, lightprod);
vec4 lightprod = this->data.state.light[index].specular
* this->data.state.material[back ? 1 : 0].specular;
state_lightprod_set_specular(back, index, lightprod);
}
}
@@ -1632,9 +1604,8 @@ void shader_set_data::state_material_set_specular(bool back, const vec4& data) {
this->data.state_update_data = true;
for (int32_t index = 0; index < SHADER_MAX_LIGHTS; index++) {
vec4 lightprod;
vec4_mult(this->data.state.light[index].specular,
this->data.state.material[back ? 1 : 0].specular, lightprod);
vec4 lightprod = this->data.state.light[index].specular
* this->data.state.material[back ? 1 : 0].specular;
state_lightprod_set_specular(back, index, lightprod);
}
}
@@ -2118,7 +2089,7 @@ static GLuint shader_compile_shader(GLenum type, const char* data, const char* f
printf("file: %s\n", file);
printf(info_log);
putchar('\n');
free(info_log);
free_def(info_log);
glDeleteShader(shader);
#if defined(CRE_DEV)
@@ -2138,7 +2109,7 @@ static GLuint shader_compile_shader(GLenum type, const char* data, const char* f
L"%ls\\shader_error\\%hs", temp_buf, file);
buf[sizeof(buf) / sizeof(wchar_t) - 1] = 0;
stream s;
file_stream s;
s.open(buf, L"wb");
s.write(data, utf8_length(data));
}
@@ -2173,7 +2144,7 @@ static GLuint shader_compile(const char* vert, const char* frag, const char* vp,
printf("vp: %s; fp: %s\n", vp, fp);
printf(info_log);
putchar('\n');
free(info_log);
free_def(info_log);
glDeleteProgram(program);
return 0;
}
@@ -2211,7 +2182,7 @@ static GLuint shader_compile_binary(const char* vert, const char* frag, const ch
printf("vp: %s; fp: %s\n", vp, fp);
printf(info_log);
putchar('\n');
free(info_log);
free_def(info_log);
glDeleteProgram(program);
return 0;
}
@@ -2225,7 +2196,7 @@ static GLuint shader_compile_binary(const char* vert, const char* frag, const ch
if (!glGetError())
break;
free(*binary);
free_def(*binary);
*buffer_size <<= 1;
*binary = force_malloc(*buffer_size);
}
@@ -2274,7 +2245,7 @@ static bool shader_parse_define(const char* data, int32_t num_uniform,
len += len_a + len_b;
if (len + 1 > *temp_size) {
free(*temp);
free_def(*temp);
*temp_size = len + 1;
*temp = force_malloc_s(char, *temp_size);
}
@@ -2288,7 +2259,7 @@ static bool shader_parse_define(const char* data, int32_t num_uniform,
return true;
}
const int32_t s = min(0x100, num_uniform);
const int32_t s = min_def(0x100, num_uniform);
size_t t_len[0x100];
char t[0x100];
@@ -2310,7 +2281,7 @@ static bool shader_parse_define(const char* data, int32_t num_uniform,
len += len_a + len_b;
if (len + 1 > *temp_size) {
free(*temp);
free_def(*temp);
*temp_size = len + 1;
*temp = force_malloc_s(char, *temp_size);
}
@@ -2353,10 +2324,10 @@ static char* shader_parse_include(char* data, farc* f) {
char** temp_ptr0 = force_malloc_s(char*, count);
char** temp_ptr1 = force_malloc_s(char*, count);
if (!temp || !temp_len || !temp_ptr0 || !temp_ptr1) {
free(temp);
free(temp_len);
free(temp_ptr0);
free(temp_ptr1);
free_def(temp);
free_def(temp_len);
free_def(temp_ptr0);
free_def(temp_ptr1);
return data;
}
@@ -2381,7 +2352,7 @@ static char* shader_parse_include(char* data, farc* f) {
t[s] = 0;
farc_file* ff = f->read_file(t);
free(t);
free_def(t);
if (!ff)
continue;
@@ -2430,13 +2401,13 @@ static char* shader_parse_include(char* data, farc* f) {
}
temp_data[pos] = 0;
free(data);
free_def(data);
for (size_t i = 0; i < count; i++)
free(temp[i]);
free(temp);
free(temp_len);
free(temp_ptr0);
free(temp_ptr1);
free_def(temp[i]);
free_def(temp);
free_def(temp_len);
free_def(temp_ptr0);
free_def(temp_ptr1);
return temp_data;
}
src/CRE/shader.hpp
+1 -1
View File
@@ -229,7 +229,7 @@ struct shader {
const bool* use_permut;
PFNSHADERBINDFUNCPROC bind_func;
int32_t bind(uint32_t sub_index);
int32_t bind(shader_set_data* set, uint32_t sub_index);
static void unbind();
};
src/CRE/shader_ft.cpp
+200 -114
View File
@@ -7,75 +7,78 @@
#include "gl_state.hpp"
enum shader_ft_sub_enum {
SHADER_FT_SUB_SHADER_FFP = 0x00,
SHADER_FT_SUB_BLINN_VERT = 0x01,
SHADER_FT_SUB_BLINN_FRAG = 0x02,
SHADER_FT_SUB_ITEM_BLINN = 0x03,
SHADER_FT_SUB_STAGE_BLINN = 0x04,
SHADER_FT_SUB_SKIN_DEFAULT = 0x05,
SHADER_FT_SUB_SSS_SKIN = 0x06,
SHADER_FT_SUB_SSS_FILTER = 0x07,
SHADER_FT_SUB_HAIR_DEFAULT = 0x08,
SHADER_FT_SUB_HAIR_ANISO = 0x09,
SHADER_FT_SUB_HAIR_NPR1 = 0x0A,
SHADER_FT_SUB_CLOTH_DEFAULT = 0x0B,
SHADER_FT_SUB_CLOTH_ANISO = 0x0C,
SHADER_FT_SUB_CLOTH_NPR1 = 0x0D,
SHADER_FT_SUB_TIGHTS = 0x0E,
SHADER_FT_SUB_SKY_DEFAULT = 0x0F,
SHADER_FT_SUB_EYE_BALL = 0x10,
SHADER_FT_SUB_EYE_LENS = 0x11,
SHADER_FT_SUB_GLASS_EYE = 0x12,
SHADER_FT_SUB_MEMBRANE = 0x13,
SHADER_FT_SUB_SHADOWMAP = 0x14,
SHADER_FT_SUB_ESM = 0x15,
SHADER_FT_SUB_ESM_GAUSS = 0x16,
SHADER_FT_SUB_ESM_FILTER = 0x17,
SHADER_FT_SUB_LIT_PROJ = 0x18,
SHADER_FT_SUB_SIMPLE = 0x19,
SHADER_FT_SUB_SILHOUETTE = 0x1A,
SHADER_FT_SUB_LAMBERT = 0x1B,
SHADER_FT_SUB_CONSTANT = 0x1C,
SHADER_FT_SUB_PEEL = 0x1D,
SHADER_FT_SUB_TONEMAP = 0x1E,
SHADER_FT_SUB_TONEMAP_NPR1 = 0x1F,
SHADER_FT_SUB_REDUCE_TEX = 0x20,
SHADER_FT_SUB_MAGNIFY = 0x21,
SHADER_FT_SUB_MLAA = 0x22,
SHADER_FT_SUB_CONTOUR = 0x23,
SHADER_FT_SUB_EXPOSURE = 0x24,
SHADER_FT_SUB_PP_GAUSS = 0x25,
SHADER_FT_SUB_SUN = 0x26,
SHADER_FT_SUB_FADE = 0x27,
SHADER_FT_SUB_WATER01 = 0x28,
SHADER_FT_SUB_WATER02 = 0x29,
SHADER_FT_SUB_WATER_RING = 0x2A,
SHADER_FT_SUB_WATER_PARTICLE = 0x2B,
SHADER_FT_SUB_SNOW_PARTICLE = 0x2C,
SHADER_FT_SUB_LEAF_PARTICLE = 0x2D,
SHADER_FT_SUB_STAR = 0x2E,
SHADER_FT_SUB_SNOW_RING = 0x2F,
SHADER_FT_SUB_SNOW_FOOTPRINT = 0x30,
SHADER_FT_SUB_SNOW_TEX_SPACE_LIGHT = 0x31,
SHADER_FT_SUB_SNOW_CALC_NORMAL = 0x32,
SHADER_FT_SUB_FLOOR = 0x33,
SHADER_FT_SUB_PUDDLE = 0x34,
SHADER_FT_SUB_SIMPLE_REFLECT = 0x35,
SHADER_FT_SUB_SIMPLE_REFRACT = 0x36,
SHADER_FT_SUB_RIPPLE_EMIT = 0x37,
SHADER_FT_SUB_RAIN = 0x38,
SHADER_FT_SUB_VOLUME_LIGHT = 0x39,
SHADER_FT_SUB_FENCE_ALPHA = 0x3A,
SHADER_FT_SUB_RIPPLE = 0x3B,
SHADER_FT_SUB_FOG_PTCL = 0x3C,
SHADER_FT_SUB_PARTICLE = 0x3D,
SHADER_FT_SUB_GLITTER_PARTICLE = 0x3E,
SHADER_FT_SUB_SHOW_VECTOR = 0x3F,
SHADER_FT_SUB_FONT = 0x40,
SHADER_FT_SUB_MOVIE = 0x41,
SHADER_FT_SUB_IMGFILTER = 0x42,
SHADER_FT_SUB_SPRITE = 0x43,
SHADER_FT_SUB_SHADER_END = 0x44,
SHADER_FT_SUB_SHADER_FFP = 0,
SHADER_FT_SUB_BLINN_VERT,
SHADER_FT_SUB_BLINN_FRAG,
SHADER_FT_SUB_ITEM_BLINN,
SHADER_FT_SUB_STAGE_BLINN,
SHADER_FT_SUB_SKIN_DEFAULT,
SHADER_FT_SUB_SSS_SKIN,
SHADER_FT_SUB_SSS_FILTER,
SHADER_FT_SUB_HAIR_DEFAULT,
SHADER_FT_SUB_HAIR_ANISO,
SHADER_FT_SUB_HAIR_NPR1,
SHADER_FT_SUB_CLOTH_DEFAULT,
SHADER_FT_SUB_CLOTH_ANISO,
SHADER_FT_SUB_CLOTH_NPR1,
SHADER_FT_SUB_TIGHTS,
SHADER_FT_SUB_SKY_DEFAULT,
SHADER_FT_SUB_EYE_BALL,
SHADER_FT_SUB_EYE_LENS,
SHADER_FT_SUB_GLASS_EYE,
SHADER_FT_SUB_MEMBRANE,
SHADER_FT_SUB_SHADOWMAP,
SHADER_FT_SUB_ESM,
SHADER_FT_SUB_ESM_GAUSS,
SHADER_FT_SUB_ESM_FILTER,
SHADER_FT_SUB_LIT_PROJ,
SHADER_FT_SUB_SIMPLE,
SHADER_FT_SUB_SILHOUETTE,
SHADER_FT_SUB_LAMBERT,
SHADER_FT_SUB_CONSTANT,
SHADER_FT_SUB_PEEL,
SHADER_FT_SUB_TONEMAP,
SHADER_FT_SUB_TONEMAP_NPR1,
SHADER_FT_SUB_REDUCE_TEX,
SHADER_FT_SUB_MAGNIFY,
//SHADER_FT_SUB_MLAA,
SHADER_FT_SUB_MLAA_EDGE,
SHADER_FT_SUB_MLAA_AREA,
SHADER_FT_SUB_MLAA_BLEND,
SHADER_FT_SUB_CONTOUR,
SHADER_FT_SUB_EXPOSURE,
SHADER_FT_SUB_PP_GAUSS,
SHADER_FT_SUB_SUN,
SHADER_FT_SUB_FADE,
SHADER_FT_SUB_WATER01,
SHADER_FT_SUB_WATER02,
SHADER_FT_SUB_WATER_RING,
SHADER_FT_SUB_WATER_PARTICLE,
SHADER_FT_SUB_SNOW_PARTICLE,
SHADER_FT_SUB_LEAF_PARTICLE,
SHADER_FT_SUB_STAR,
SHADER_FT_SUB_SNOW_RING,
SHADER_FT_SUB_SNOW_FOOTPRINT,
SHADER_FT_SUB_SNOW_TEX_SPACE_LIGHT,
SHADER_FT_SUB_SNOW_CALC_NORMAL,
SHADER_FT_SUB_FLOOR,
SHADER_FT_SUB_PUDDLE,
SHADER_FT_SUB_SIMPLE_REFLECT,
SHADER_FT_SUB_SIMPLE_REFRACT,
SHADER_FT_SUB_RIPPLE_EMIT,
SHADER_FT_SUB_RAIN,
SHADER_FT_SUB_VOLUME_LIGHT,
SHADER_FT_SUB_FENCE_ALPHA,
SHADER_FT_SUB_RIPPLE,
SHADER_FT_SUB_FOG_PTCL,
SHADER_FT_SUB_PARTICLE,
SHADER_FT_SUB_GLITTER_PARTICLE,
SHADER_FT_SUB_SHOW_VECTOR,
SHADER_FT_SUB_FONT,
SHADER_FT_SUB_MOVIE,
SHADER_FT_SUB_IMGFILTER,
SHADER_FT_SUB_SPRITE,
SHADER_FT_SUB_SHADER_END,
};
static const int32_t blinn_vert_vpt_unival_max[] = {
@@ -342,12 +345,38 @@ static const int32_t magnify_fpt_unival_max[] = {
7,
};
static const int32_t mlaa_vpt_unival_max[] = {
0, 0, 2, 0,
/*static const int32_t mlaa_vpt_unival_max[] = {
//0, 0, 2, 0,
0, 2, 0, // 1st removed
};
static const int32_t mlaa_fpt_unival_max[] = {
1, 1, 2, 2,
//1, 1, 2, 2,
1, 2, 2, // 1st removed
};*/
static const int32_t mlaa_edge_vpt_unival_max[] = {
0,
};
static const int32_t mlaa_edge_fpt_unival_max[] = {
1,
};
static const int32_t mlaa_area_vpt_unival_max[] = {
0,
};
static const int32_t mlaa_area_fpt_unival_max[] = {
2,
};
static const int32_t mlaa_blend_vpt_unival_max[] = {
0,
};
static const int32_t mlaa_blend_fpt_unival_max[] = {
1,
};
static const int32_t contour_vpt_unival_max[] = {
@@ -926,7 +955,7 @@ static const shader_sub_table MAGNIFY_table[] = {
},
};
static const shader_sub_table MLAA_table[] = {
/*static const shader_sub_table MLAA_table[] = {
{
SHADER_FT_SUB_MLAA,
mlaa_vpt_unival_max,
@@ -934,6 +963,36 @@ static const shader_sub_table MLAA_table[] = {
"mlaa",
"mlaa",
},
};*/
static const shader_sub_table MLAA_EDGE_table[] = {
{
SHADER_FT_SUB_MLAA_EDGE,
mlaa_edge_vpt_unival_max,
mlaa_edge_fpt_unival_max,
"mlaa_edge",
"mlaa_edge",
},
};
static const shader_sub_table MLAA_AREA_table[] = {
{
SHADER_FT_SUB_MLAA_AREA,
mlaa_area_vpt_unival_max,
mlaa_area_fpt_unival_max,
"mlaa_area",
"mlaa_area",
},
};
static const shader_sub_table MLAA_BLEND_table[] = {
{
SHADER_FT_SUB_MLAA_BLEND,
mlaa_blend_vpt_unival_max,
mlaa_blend_fpt_unival_max,
"mlaa_blend",
"mlaa_blend",
},
};
static const shader_sub_table CONTOUR_table[] = {
@@ -1524,18 +1583,30 @@ static const uniform_name TONEMAP_uniform[] = {
static const uniform_name REDUCE_uniform[] = {
U_REDUCE,
U01,
U_ALPHA_MASK,
};
static const uniform_name MAGNIFY_uniform[] = {
U_MAGNIFY,
};
static const uniform_name MLAA_uniform[] = {
U16,
U01,
/*static const uniform_name MLAA_uniform[] = {
//U16, // 1st removed
U_ALPHA_MASK,
U_MLAA,
U20,
U_MLAA_SEARCH,
};*/
static const uniform_name MLAA_EDGE_uniform[] = {
U_ALPHA_MASK,
};
static const uniform_name MLAA_AREA_uniform[] = {
U_MLAA_SEARCH,
};
static const uniform_name MLAA_BLEND_uniform[] = {
U_ALPHA_MASK,
};
static const uniform_name CONTOUR_uniform[] = {
@@ -1786,8 +1857,8 @@ static const bool SSS_SKIN_permut[] = {
static const bool SSS_FILT_permut[] = {
true,
false,
false,
true,
true,
};
static const bool HAIR_permut[] = {
@@ -1969,32 +2040,44 @@ static const bool TONEMAP_permut[] = {
};
static const bool REDUCE_permut[] = {
false,
false,
true,
true,
};
static const bool MAGNIFY_permut[] = {
false,
true,
};
static const bool MLAA_permut[] = {
false,
false,
/*static const bool MLAA_permut[] = {
//true, // 1st removed
true,
true,
true,
};*/
static const bool MLAA_EDGE_permut[] = {
true,
};
static const bool MLAA_AREA_permut[] = {
true,
};
static const bool MLAA_BLEND_permut[] = {
true,
};
static const bool CONTOUR_permut[] = {
false,
true,
false,
};
static const bool EXPOSURE_permut[] = {
false,
true,
};
static const bool GAUSS_permut[] = {
false,
true,
};
static const bool SUN_permut[] = {
@@ -2150,7 +2233,7 @@ static const bool MOVIE_permut[] = {
};
static const bool IMGFILT_permut[] = {
false,
true,
};
static const bool SPRITE_permut[] = {
@@ -2236,7 +2319,10 @@ static const shader_table shader_ft_table[] = {
shader_table_struct(TONEMAP),
shader_table_struct(REDUCE),
shader_table_struct(MAGNIFY),
shader_table_struct(MLAA),
//shader_table_struct(MLAA),
shader_table_struct(MLAA_EDGE),
shader_table_struct(MLAA_AREA),
shader_table_struct(MLAA_BLEND),
shader_table_struct(CONTOUR),
shader_table_struct(EXPOSURE),
shader_table_struct(GAUSS),
@@ -2356,9 +2442,9 @@ static void glass_eye_calc(glass_eye_struct* glass_eye) {
float_t v2 = glass_eye->field_28;
glass_eye->field_64 = glass_eye->field_2C / v2;
glass_eye->field_90 = glass_eye->field_58;
vec3_mult_scalar(glass_eye->field_30, v2, glass_eye->field_68);
vec3_mult_scalar(glass_eye->field_3C, v2, glass_eye->field_74);
vec3_mult_scalar(glass_eye->field_48, v2, glass_eye->field_80);
glass_eye->field_68 = glass_eye->field_30 * v2;
glass_eye->field_74 = glass_eye->field_3C * v2;
glass_eye->field_80 = glass_eye->field_48 * v2;
glass_eye->field_8C = glass_eye->field_54 * v2;
if (glass_eye->field_B0 == 0) {
glass_eye->field_A0 = vec4_null;
@@ -2386,9 +2472,9 @@ static void glass_eye_calc(glass_eye_struct* glass_eye) {
static void glass_eye_set(glass_eye_struct* glass_eye, shader_set_data* set) {
vec4 temp;
vec3_mult(glass_eye->field_68, glass_eye->field_68, *(vec3*)&temp);
*(vec3*)&temp = glass_eye->field_68 * glass_eye->field_68;
temp.w = temp.z;
vec3_div(vec3_identity, *(vec3*)&temp, *(vec3*)&temp);
*(vec3*)&temp = vec3::rcp(*(vec3*)&temp);
set->local_vert_set(0x0A, temp);
set->local_frag_set(0x0A, temp);
@@ -2402,17 +2488,17 @@ static void glass_eye_set(glass_eye_struct* glass_eye, shader_set_data* set) {
temp = glass_eye->field_A0;
set->local_vert_set(0x0D, temp);
vec3_mult(glass_eye->field_90, glass_eye->field_90, *(vec3*)&temp);
*(vec3*)&temp = glass_eye->field_90 * glass_eye->field_90;
temp.w = temp.z;
vec3_div(vec3_identity, *(vec3*)&temp, *(vec3*)&temp);
*(vec3*)&temp = vec3::rcp(*(vec3*)&temp);
set->local_vert_set(0x0E, temp);
temp = glass_eye->field_10;
set->local_vert_set(0x0F, temp);
vec3_mult(glass_eye->field_68, glass_eye->field_68, *(vec3*)&temp);
*(vec3*)&temp = glass_eye->field_68 * glass_eye->field_68;
temp.w = temp.z;
vec3_div(vec3_identity, *(vec3*)&temp, *(vec3*)&temp);
*(vec3*)&temp = vec3::rcp(*(vec3*)&temp);
set->local_vert_set(0x0E, temp);
float_t v2 = (glass_eye->field_20 - glass_eye->field_24) / (glass_eye->field_20 + glass_eye->field_24);
@@ -2425,46 +2511,46 @@ static void glass_eye_set(glass_eye_struct* glass_eye, shader_set_data* set) {
float_t v4 = (glass_eye->field_24 * glass_eye->field_24) / (glass_eye->field_20 * glass_eye->field_20);
set->local_frag_set(0x0E, v4, 1.0f - v4, glass_eye->field_24 / glass_eye->field_20, 0.0f);
vec3_mult(glass_eye->field_74, glass_eye->field_74, *(vec3*)&temp);
*(vec3*)&temp = glass_eye->field_74 * glass_eye->field_74;
temp.w = -1.0f;
vec3_div(vec3_identity, *(vec3*)&temp, *(vec3*)&temp);
*(vec3*)&temp = vec3::rcp(*(vec3*)&temp);
set->local_frag_set(0x0F, temp);
vec3_mult(glass_eye->field_68, glass_eye->field_68, *(vec3*)&temp);
*(vec3*)&temp = glass_eye->field_68 * glass_eye->field_68;
temp.w = -1.0f;
vec3_div(vec3_identity, *(vec3*)&temp, *(vec3*)&temp);
*(vec3*)&temp = vec3::rcp(*(vec3*)&temp);
set->local_frag_set(0x10, temp);
vec3_mult(glass_eye->field_80, glass_eye->field_80, *(vec3*)&temp);
*(vec3*)&temp = glass_eye->field_80 * glass_eye->field_80;
temp.w = -1.0f;
vec3_div(vec3_identity, *(vec3*)&temp, *(vec3*)&temp);
*(vec3*)&temp = vec3::rcp(*(vec3*)&temp);
set->local_frag_set(0x11, temp);
vec2_mult(*(vec2*)&glass_eye->field_0, *(vec2*)&glass_eye->field_74, *(vec2*)&temp);
*(vec2*)&temp = *(vec2*)&glass_eye->field_0 * *(vec2*)&glass_eye->field_74;
temp.z = glass_eye->field_64 * 1.442695f;
temp.w = glass_eye->field_8C;
vec2_div(vec2_identity, *(vec2*)&temp, *(vec2*)&temp);
*(vec2*)&temp = vec2::rcp(*(vec2*)&temp);
set->local_frag_set(0x12, temp);
}
static void shader_bind_blinn(shader_set_data* set, shader* shad) {
shad->bind(uniform_value[U_NORMAL]
shad->bind(set, uniform_value[U_NORMAL]
? SHADER_FT_SUB_BLINN_FRAG : SHADER_FT_SUB_BLINN_VERT);
}
static void shader_bind_cloth(shader_set_data* set, shader* shad) {
shad->bind(uniform_value[U_NPR] ? SHADER_FT_SUB_CLOTH_NPR1
shad->bind(set, uniform_value[U_NPR] ? SHADER_FT_SUB_CLOTH_NPR1
: (uniform_value[U_ANISO] ? SHADER_FT_SUB_CLOTH_ANISO : SHADER_FT_SUB_CLOTH_DEFAULT));
}
static void shader_bind_hair(shader_set_data* set, shader* shad) {
shad->bind(uniform_value[U_NPR] ? SHADER_FT_SUB_HAIR_NPR1
shad->bind(set, uniform_value[U_NPR] ? SHADER_FT_SUB_HAIR_NPR1
: (uniform_value[U_ANISO] ? SHADER_FT_SUB_HAIR_ANISO : SHADER_FT_SUB_HAIR_DEFAULT));
}
static void shader_bind_membrane(shader_set_data* set, shader* shad) {
uniform_value[U_MEMBRANE] = 3;
if (shad->bind(SHADER_FT_SUB_MEMBRANE) < 0)
if (shad->bind(set, SHADER_FT_SUB_MEMBRANE) < 0)
return;
/*uint32_t(* sub_140192E00)() = (void*)0x0000000140192E00;
@@ -2481,13 +2567,13 @@ static void shader_bind_membrane(shader_set_data* set, shader* shad) {
static void shader_bind_eye_ball(shader_set_data* set, shader* shad) {
uniform_value[U18] = 0;
if (set->shaders[SHADER_FT_GLASEYE].bind(SHADER_FT_SUB_GLASS_EYE) >= 0) {
if (set->shaders[SHADER_FT_GLASEYE].bind(set, SHADER_FT_SUB_GLASS_EYE) >= 0) {
glass_eye_calc(&glass_eye);
glass_eye_set(&glass_eye, set);
}
}
static void shader_bind_tone_map(shader_set_data* set, shader* shad) {
shad->bind(uniform_value[U_NPR] == 1
shad->bind(set, uniform_value[U_NPR] == 1
? SHADER_FT_SUB_TONEMAP_NPR1 : SHADER_FT_SUB_TONEMAP);
}
src/CRE/shader_ft.hpp
+66 -63
View File
@@ -9,69 +9,72 @@
#include "shader.hpp"
enum shader_ft_enum {
SHADER_FT_FFP = 0x00,
SHADER_FT_BLINN = 0x01,
SHADER_FT_ITEM = 0x02,
SHADER_FT_STAGE = 0x03,
SHADER_FT_SKIN = 0x04,
SHADER_FT_SSS_SKIN = 0x05,
SHADER_FT_SSS_FILT = 0x06,
SHADER_FT_HAIR = 0x07,
SHADER_FT_CLOTH = 0x08,
SHADER_FT_TIGHTS = 0x09,
SHADER_FT_SKY = 0x0A,
SHADER_FT_EYEBALL = 0x0B,
SHADER_FT_EYELENS = 0x0C,
SHADER_FT_GLASEYE = 0x0D,
SHADER_FT_MEMBRAN = 0x0E,
SHADER_FT_SHDMAP = 0x0F,
SHADER_FT_ESM = 0x10,
SHADER_FT_ESMGAUSS = 0x11,
SHADER_FT_ESMFILT = 0x12,
SHADER_FT_LITPROJ = 0x13,
SHADER_FT_SIMPLE = 0x14,
SHADER_FT_SIL = 0x15,
SHADER_FT_LAMBERT = 0x16,
SHADER_FT_CONSTANT = 0x17,
SHADER_FT_PEEL = 0x18,
SHADER_FT_TONEMAP = 0x19,
SHADER_FT_REDUCE = 0x1A,
SHADER_FT_MAGNIFY = 0x1B,
SHADER_FT_MLAA = 0x1C,
SHADER_FT_CONTOUR = 0x1D,
SHADER_FT_EXPOSURE = 0x1E,
SHADER_FT_GAUSS = 0x1F,
SHADER_FT_SUN = 0x20,
SHADER_FT_FADE = 0x21,
SHADER_FT_WATER01 = 0x22,
SHADER_FT_WATER02 = 0x23,
SHADER_FT_WATRING = 0x24,
SHADER_FT_W_PTCL = 0x25,
SHADER_FT_SNOW_PT = 0x26,
SHADER_FT_LEAF_PT = 0x27,
SHADER_FT_STAR = 0x28,
SHADER_FT_SNORING = 0x29,
SHADER_FT_SN_FOOT = 0x2A,
SHADER_FT_SN_TSL = 0x2B,
SHADER_FT_SN_NRM = 0x2C,
SHADER_FT_FLOOR = 0x2D,
SHADER_FT_PUDDLE = 0x2E,
SHADER_FT_S_REFL = 0x2F,
SHADER_FT_S_REFR = 0x30,
SHADER_FT_RIPEMIT = 0x31,
SHADER_FT_RAIN = 0x32,
SHADER_FT_VOLLIT = 0x33,
SHADER_FT_FENCE = 0x34,
SHADER_FT_RIPPLE = 0x35,
SHADER_FT_FOGPTCL = 0x36,
SHADER_FT_PARTICL = 0x37,
SHADER_FT_GLITTER_PT = 0x38,
SHADER_FT_SHOWVEC = 0x39,
SHADER_FT_FONT = 0x3A,
SHADER_FT_MOVIE = 0x3B,
SHADER_FT_IMGFILT = 0x3C,
SHADER_FT_SPRITE = 0x3D,
SHADER_FT_END = 0x3E,
SHADER_FT_FFP = 0,
SHADER_FT_BLINN,
SHADER_FT_ITEM,
SHADER_FT_STAGE,
SHADER_FT_SKIN,
SHADER_FT_SSS_SKIN,
SHADER_FT_SSS_FILT,
SHADER_FT_HAIR,
SHADER_FT_CLOTH,
SHADER_FT_TIGHTS,
SHADER_FT_SKY,
SHADER_FT_EYEBALL,
SHADER_FT_EYELENS,
SHADER_FT_GLASEYE,
SHADER_FT_MEMBRAN,
SHADER_FT_SHDMAP,
SHADER_FT_ESM,
SHADER_FT_ESMGAUSS,
SHADER_FT_ESMFILT,
SHADER_FT_LITPROJ,
SHADER_FT_SIMPLE,
SHADER_FT_SIL,
SHADER_FT_LAMBERT,
SHADER_FT_CONSTANT,
SHADER_FT_PEEL,
SHADER_FT_TONEMAP,
SHADER_FT_REDUCE,
SHADER_FT_MAGNIFY,
//SHADER_FT_MLAA,
SHADER_FT_MLAA_EDGE,
SHADER_FT_MLAA_AREA,
SHADER_FT_MLAA_BLEND,
SHADER_FT_CONTOUR,
SHADER_FT_EXPOSURE,
SHADER_FT_GAUSS,
SHADER_FT_SUN,
SHADER_FT_FADE,
SHADER_FT_WATER01,
SHADER_FT_WATER02,
SHADER_FT_WATRING,
SHADER_FT_W_PTCL,
SHADER_FT_SNOW_PT,
SHADER_FT_LEAF_PT,
SHADER_FT_STAR,
SHADER_FT_SNORING,
SHADER_FT_SN_FOOT,
SHADER_FT_SN_TSL,
SHADER_FT_SN_NRM,
SHADER_FT_FLOOR,
SHADER_FT_PUDDLE,
SHADER_FT_S_REFL,
SHADER_FT_S_REFR,
SHADER_FT_RIPEMIT,
SHADER_FT_RAIN,
SHADER_FT_VOLLIT,
SHADER_FT_FENCE,
SHADER_FT_RIPPLE,
SHADER_FT_FOGPTCL,
SHADER_FT_PARTICL,
SHADER_FT_GLITTER_PT,
SHADER_FT_SHOWVEC,
SHADER_FT_FONT,
SHADER_FT_MOVIE,
SHADER_FT_IMGFILT,
SHADER_FT_SPRITE,
SHADER_FT_END,
};
extern shader_set_data shaders_ft;
src/CRE/shader_glsl.cpp
+21 -20
View File
@@ -4,6 +4,7 @@
*/
#include "shader_glsl.hpp"
#include "../KKdLib/io/file_stream.hpp"
#include "../KKdLib/hash.hpp"
#include "../KKdLib/str_utils.hpp"
#include "gl_state.hpp"
@@ -73,9 +74,9 @@ void shader_glsl::load(const char* vert, const char* frag,
GLuint vert_shad = shader_compile(GL_VERTEX_SHADER, vert_data);
GLuint geom_shad = shader_compile(GL_GEOMETRY_SHADER, geom_data);
free(frag_data);
free(vert_data);
free(geom_data);
free_def(frag_data);
free_def(vert_data);
free_def(geom_data);
program = glCreateProgram();
if (frag_shad)
@@ -91,10 +92,10 @@ void shader_glsl::load(const char* vert, const char* frag,
if (!success) {
GLchar* info_log = force_malloc_s(GLchar, 0x10000);
glGetProgramInfoLog(program, 0x10000, 0, info_log);
printf("Program FBO Shader linking error: %s\n", param->name);
printf("Program linking error: %s\n", param->name);
printf(info_log);
putchar('\n');
free(info_log);
free_def(info_log);
}
if (frag_shad)
@@ -113,7 +114,7 @@ void shader_glsl::load_file(const char* vert_path, const char* frag_path,
uniform.clear();
uniform_block.clear();
stream st;
file_stream st;
size_t l;
char* vert = 0;
@@ -121,7 +122,7 @@ void shader_glsl::load_file(const char* vert_path, const char* frag_path,
char* geom = 0;
st.open(vert_path, "rb");
if (st.io.stream) {
if (st.check_not_null()) {
l = st.length;
vert = force_malloc_s(char, l + 1);
st.read(vert, l);
@@ -130,7 +131,7 @@ void shader_glsl::load_file(const char* vert_path, const char* frag_path,
st.close();
st.open(frag_path, "rb");
if (st.io.stream) {
if (st.check_not_null()) {
l = st.length;
frag = force_malloc_s(char, l + 1);
st.read(frag, l);
@@ -139,7 +140,7 @@ void shader_glsl::load_file(const char* vert_path, const char* frag_path,
st.close();
st.open(geom_path, "rb");
if (st.io.stream) {
if (st.check_not_null()) {
l = st.length;
geom = force_malloc_s(char, l + 1);
st.read(geom, l);
@@ -148,8 +149,8 @@ void shader_glsl::load_file(const char* vert_path, const char* frag_path,
st.close();
load(vert, frag, geom, param);
free(vert);
free(frag);
free_def(vert);
free_def(frag);
}
void shader_glsl::load_file(const wchar_t* vert_path, const wchar_t* frag_path,
@@ -160,7 +161,7 @@ void shader_glsl::load_file(const wchar_t* vert_path, const wchar_t* frag_path,
uniform.clear();
uniform_block.clear();
stream st;
file_stream st;
size_t l;
char* vert = 0;
@@ -168,7 +169,7 @@ void shader_glsl::load_file(const wchar_t* vert_path, const wchar_t* frag_path,
char* geom = 0;
st.open(vert_path, L"rb");
if (st.io.stream) {
if (st.check_not_null()) {
l = st.length;
vert = force_malloc_s(char, l + 1);
st.read(vert, l);
@@ -177,7 +178,7 @@ void shader_glsl::load_file(const wchar_t* vert_path, const wchar_t* frag_path,
st.close();
st.open(frag_path, L"rb");
if (st.io.stream) {
if (st.check_not_null()) {
l = st.length;
frag = force_malloc_s(char, l + 1);
st.read(frag, l);
@@ -186,7 +187,7 @@ void shader_glsl::load_file(const wchar_t* vert_path, const wchar_t* frag_path,
st.close();
st.open(geom_path, L"rb");
if (st.io.stream) {
if (st.check_not_null()) {
l = st.length;
geom = force_malloc_s(char, l + 1);
st.read(geom, l);
@@ -195,8 +196,8 @@ void shader_glsl::load_file(const wchar_t* vert_path, const wchar_t* frag_path,
st.close();
load(vert, frag, geom, param);
free(vert);
free(frag);
free_def(vert);
free_def(frag);
}
void shader_glsl::set(const char* name, bool value) {
@@ -448,7 +449,7 @@ static GLuint shader_compile(GLenum type, const char* data) {
printf("Shader compile error: ");
printf(info_log);
putchar('\n');
free(info_log);
free_def(info_log);
}
return shader;
}
@@ -513,7 +514,7 @@ static char* shader_parse(char* data, const char* parse_string, const char* repl
memcpy(temp_data + pos, replace_string, len_b);
pos += len_b;
memcpy(temp_data + pos, def, len_c);
free(data);
free_def(data);
return temp_data;
}
@@ -561,6 +562,6 @@ static char* shader_parse_define(char* data, shader_glsl_param* param) {
pos += temp_len[i];
}
memcpy(temp_data + pos, def, len_b);
free(data);
free_def(data);
return temp_data;
}
src/CRE/sound.cpp
+1775
View File
File diff suppressed because it is too large Load Diff
src/CRE/sound.hpp
+352
View File
@@ -0,0 +1,352 @@
/*
by korenkonder
GitHub/GitLab: korenkonder
*/
#pragma once
#include "../KKdLib/default.hpp"
#include "../KKdLib/farc.hpp"
#include "file_handler.hpp"
#include "lock.hpp"
#include "time.hpp"
#include <map>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
#include <audioclient.h>
#include <mmdeviceapi.h>
#include <mmreg.h>
#include <mmsystem.h>
struct sound_buffer_data {
float_t spk_l;
float_t spk_r;
float_t hph_l;
float_t hph_r;
};
namespace sound {
namespace wasapi {
enum AudioFormat {
AUDIO_FORMAT_I16 = 0,
AUDIO_FORMAT_I24,
AUDIO_FORMAT_I32,
AUDIO_FORMAT_F32,
};
struct Mixer;
struct SEChannel;
struct StreamingChannel;
struct System {
WAVEFORMATEXTENSIBLE wave_format;
IMMDeviceEnumerator* pEnumerator;
IMMDevice* pDevice;
IAudioClient* pAudioClient;
uint32_t samples_count;
IAudioRenderClient* pRenderClient;
IAudioClockAdjustment* pClockAdjustment;
HANDLE hEvent;
int32_t channels;
int32_t sample_rate;
int32_t bit_depth;
Mixer* mixer;
std::thread* thread;
lock_uint32_t thread_state;
AudioFormat format;
System();
virtual ~System();
void Init(size_t se_channels_count, size_t streaming_channels_count,
bool separate_speakers_headphones = false);
void Reset();
static void ThreadMain(System* system);
};
struct Mixer {
System* system;
SEChannel* se_channels;
size_t se_channels_count;
StreamingChannel* streaming_channels;
size_t streaming_channels_count;
sound_buffer_data* mix_buffer;
size_t mix_buffer_size;
std::mutex volume_mtx;
float_t master_volume;
float_t channels_volume[4];
Mixer(System* system);
virtual ~Mixer();
void FillBuffer(void* buffer, size_t samples_count,
bool disable_headphones_volume, bool invert_phase, AudioFormat format);
SEChannel* GetSEChannel(size_t channel);
StreamingChannel* GetStreamingChannel(size_t channel);
bool Init(size_t se_channels_count, size_t streaming_channels_count, size_t samples_count);
void Reset();
void SetChannelsVolume(int32_t mask, float_t value);
void SetMasterVolume(float_t value);
};
struct SEChannel {
Mixer* mixer;
lock_uint32_t play_state;
std::mutex mtx;
float_t master_volume;
float_t channels_volume[4];
float_t* buffer;
size_t buffer_size;
size_t channels;
size_t samples_count;
size_t sample_rate;
size_t loop_start;
size_t loop_end;
size_t current_sample;
SEChannel();
virtual ~SEChannel();
void FillBuffer(sound_buffer_data* buffer, size_t samples_count, float_t volume);
bool Init(Mixer* mixer);
float_t* InitBuffer(size_t channels, size_t samples_count, size_t sample_rate);
bool Play(size_t loop_start = 0, size_t loop_end = 0);
void Reset();
void ResetData();
void ResetDataProt();
void SetChannelsVolume(int32_t mask, float_t value);
void SetMasterVolume(float_t value);
};
struct StreamingChannel {
Mixer* mixer;
sound_buffer_data* buffer;
size_t buffer_size;
lock_uint32_t playing_state;
lock_uint32_t reset_state;
std::mutex mtx;
float_t master_volume;
float_t channels_volume[4];
void(*callback_func)(sound_buffer_data* buffer, size_t samples_count, void* data);
void* callback_data;
StreamingChannel();
virtual ~StreamingChannel();
void FillBuffer(sound_buffer_data* buffer, size_t samples_count, float_t volume);
bool Init(Mixer* mixer, size_t samples_count);
void Reset();
void ResetData();
bool SetCallback(void(*func)(sound_buffer_data* buffer,
size_t samples_count, void* data), void* data);
void SetChannelsVolume(int32_t mask, float_t value);
void SetMasterVolume(float_t value);
};
}
}
enum SoundCueDataState {
SOUND_CUE_DATA_STATE_NONE = 0,
SOUND_CUE_DATA_STATE_LOAD,
SOUND_CUE_DATA_STATE_RESET,
SOUND_CUE_DATA_STATE_MAX,
};
enum WaveAudioDataFormat {
WAVE_AUDIO_DATA_FORMAT_NONE = 0,
WAVE_AUDIO_DATA_FORMAT_RIFF = 1,
WAVE_AUDIO_DATA_FORMAT_DIVA = 3,
};
struct sound_db_farc {
std::string file_path;
bool loaded;
p_file_handler file_handler;
farc farc;
sound_db_farc();
~sound_db_farc();
bool load();
bool read(const char* file_path);
bool unload();
};
struct sound_db_property {
sound_db_farc* farc;
std::string file_name;
float_t volume;
size_t loop_start;
size_t loop_end;
float_t release_time;
//std::string field_28;
//int32_t field_48;
sound_db_property();
~sound_db_property();
};
struct SoundCue;
struct SoundCueVolume {
SoundCue* cue;
float_t value;
bool set;
inline SoundCueVolume(SoundCue* cue) : cue(cue), value(), set() {
}
inline void SetValue(float_t value) {
this->value = value;
set = true;
}
};
struct SoundCue {
lock_uint32_t thread_state;
lock_uint32_t data_state;
std::thread* thread;
std::mutex mtx;
std::condition_variable cnd;
SoundCueVolume* volume;
int32_t queue_index;
std::string name;
sound_db_property* property;
int32_t counter;
float_t release_time;
time_struct time;
lock_uint32_t load_state;
sound::wasapi::SEChannel* se_channel;
SoundCue();
~SoundCue();
bool CanPlay();
void Ctrl();
int32_t Load(int32_t queue_index, const char* name, float_t volume);
void LoadData();
void Play();
void PlayProt();
void Release(bool force_release);
void ReleaseProt(bool force_release);
void Reset();
void ResetData();
void SetSEChannel(sound::wasapi::SEChannel* se_channel);
static void ThreadMain(SoundCue* cue);
};
struct WaveAudioDataFileMemoryStream {
FILE* file;
const void* data;
size_t size;
size_t position;
inline WaveAudioDataFileMemoryStream(const void* data, size_t size) : file(),
data(data), size(size), position() {
}
};
struct WaveAudioData {
WaveAudioDataFormat format;
size_t channels;
size_t sample_rate;
size_t bit_depth;
size_t samples_count;
size_t position;
size_t data_size;
bool has_loop;
size_t loop_start;
size_t loop_end;
WaveAudioData();
~WaveAudioData();
bool Read(WaveAudioDataFileMemoryStream* fms);
bool ReadData(const void* data, size_t size);
bool ReadDiva(WaveAudioDataFileMemoryStream* fms);
void Reset();
};
struct WaveAudio {
float_t* buffer;
size_t buffer_size;
WaveAudioData data;
WaveAudio();
bool Read(sound_db_farc* farc, const char* file_name);
void Reset();
};
#define SOUND_WORK_SE_QUEUE_COUNT 5
#define SOUND_WORK_STREAMING_COUNT 3
struct SoundWork {
std::map<std::string, sound_db_property> properties;
sound_db_farc farcs[16];
SoundCue cues[32];
int32_t counter;
std::vector<std::string> names_list;
bool se_queue_enable[SOUND_WORK_SE_QUEUE_COUNT];
bool streaming_enable[SOUND_WORK_STREAMING_COUNT];
float_t speakers_volume;
bool speakers_volume_changed;
float_t headphones_volume;
bool headphones_volume_changed;
float_t se_queue_volume[5];
float_t se_volume;
SoundWork();
virtual ~SoundWork();
sound_db_property* FindProperty(const char* name);
bool ParseProperty(sound_db_farc* snd_db_farc);
bool UnloadProperty(const char* file_path);
};
extern float_t get_min_headphones_volume();
extern float_t get_max_headphones_volume();
extern float_t get_max_speakers_volume();
extern float_t db_to_ratio(int32_t value);
extern int32_t ratio_to_db(float_t value);
extern void sound_init();
extern void sound_ctrl();
extern void sound_free();
extern float_t sound_cue_queue_volume_array_get_max(int32_t queue_index);
extern float_t sound_cue_queue_volume_array_get_min(int32_t queue_index);
extern bool sound_work_cue_release(int32_t queue_index, const char* name, bool force_release = true);
extern SoundCue* sound_work_get_cue(int32_t queue_index, const char* name);
extern bool sound_work_get_cue_can_play(int32_t queue_index, const char* name);
extern sound_db_farc* sound_work_get_farc(const char* file_path);
extern float_t sound_work_get_headphones_volume();
extern float_t sound_work_get_speakers_volume();
extern bool sound_work_has_property(const char* name);
extern bool sound_work_load_farc(const char* file_path);
extern int32_t sound_work_play_se(int32_t queue_index, const char* name, float_t volume);
extern bool sound_work_read_farc(const char* file_path);
extern void sound_work_release_farc_se(const char* file_path);
extern bool sound_work_release_se(const char* name, bool force_release = true);
extern float_t sound_cue_queue_volume_array_get_max(int32_t queue_index);
extern float_t sound_cue_queue_volume_array_get_min(int32_t queue_index);
extern sound::wasapi::System* sound_wasapi_system_data_get();
extern void sound_work_set_headphones_volume(float_t value);
extern void sound_work_set_se_queue_volume(int32_t queue_index, float_t value);
extern void sound_work_set_speakers_volume(float_t value);
extern bool sound_work_unload_farc(const char* file_path);
extern void wave_audio_storage_init();
extern void wave_audio_storage_clear();
extern WaveAudio* wave_audio_storage_get_wave_audio(std::string& name);
extern bool wave_audio_storage_load_wave_audio(std::string& name);
extern void wave_audio_storage_unload_wave_audio(std::string& name);
extern void wave_audio_storage_free();
src/CRE/stage.cpp
+1 -1
View File
@@ -237,7 +237,7 @@ static void stage_detail::TaskStage_CtrlInner(stage_detail::TaskStage* a1) {
if (!a1->state) {
a1->state = 3;
int32_t stage_count = (int32_t)a1->load_stage_indices.size();
stage_count = min(stage_count, TASK_STAGE_STAGE_COUNT);
stage_count = min_def(stage_count, TASK_STAGE_STAGE_COUNT);
for (int32_t i = 0; i < stage_count; i++)
if (a1->stages[i].index == -1)
stage_set_by_stage_index(&a1->stages[i], a1->load_stage_indices[i], stage_counter++);
src/CRE/stage_modern.cpp
+3 -3
View File
@@ -208,7 +208,7 @@ static void stage_detail::TaskStageModern_CtrlInner(stage_detail::TaskStageModer
if (!a1->state) {
a1->state = 3;
int32_t stage_count = (int32_t)a1->load_stage_hashes.size();
stage_count = min(stage_count, TASK_STAGE_STAGE_COUNT);
stage_count = min_def(stage_count, TASK_STAGE_STAGE_COUNT);
for (int32_t i = 0; i < stage_count; i++)
if (a1->stages[i].hash == -1 || a1->stages[i].hash == hash_murmurhash_empty)
stage_modern_set_by_stage_hash(&a1->stages[i],
@@ -687,11 +687,11 @@ static void stage_modern_set_by_stage_hash(stage_modern* s, int32_t stage_hash,
char set_name[11];
set_name[0] = 0;
if (!strncmp(name, "STGPV", min(name_len, 5))) {
if (!strncmp(name, "STGPV", min_def(name_len, 5))) {
memcpy(set_name, name, 8);
set_name[8] = 0;
}
else if (!strncmp(name, "STGD2PV", min(name_len, 7))) {
else if (!strncmp(name, "STGD2PV", min_def(name_len, 7))) {
memcpy(set_name, name, 10);
set_name[10] = 0;
}
src/CRE/static_var.cpp
+1 -1
View File
@@ -43,7 +43,7 @@ const mat3 sv_ypbpr_to_rgb = {
};
void sv_anisotropy_set(int32_t value) {
sv_anisotropy = 1 << (int32_t)roundf(log2f((float_t)clamp(value, 1, sv_max_texture_max_anisotropy)));
sv_anisotropy = 1 << (int32_t)roundf(log2f((float_t)clamp_def(value, 1, sv_max_texture_max_anisotropy)));
if (sv_anisotropy != sv_old_anisotropy)
sv_anisotropy_changed = true;
sv_old_anisotropy = sv_anisotropy;
src/CRE/static_var.hpp
+3 -3
View File
@@ -22,7 +22,7 @@ enum draw_pass_3d_type {
enum uniform_name {
U_NONE = 0x00,
U01 = 0x01,
U_ALPHA_MASK = 0x01,
U_ALPHA_TEST = 0x02,
U_ANISO = 0x03,
U_AET_BACK = 0x04,
@@ -53,7 +53,7 @@ enum uniform_name {
U_MAGNIFY = 0x1D,
U_MEMBRANE = 0x1E,
U_MLAA = 0x1F,
U20 = 0x20,
U_MLAA_SEARCH = 0x20,
U_MORPH_COLOR = 0x21,
U_MORPH = 0x22,
U_MOVIE = 0x23,
@@ -102,7 +102,7 @@ extern int32_t sv_max_texture_max_anisotropy;
extern bool sv_anisotropy_changed;
extern int32_t sv_anisotropy;
extern int32_t uniform_value[];
extern int32_t uniform_value[U_MAX];
extern const vec3 sv_rgb_to_luma;
extern const mat3 sv_rgb_to_ypbpr;
src/CRE/task.cpp
+4 -4
View File
@@ -116,7 +116,7 @@ namespace app {
}
size_t len = utf8_length(name);
len = min(len, sizeof(this->name) - 1);
len = min_def(len, sizeof(this->name) - 1);
memmove(&this->name, name, len);
this->name[len] = 0;
}
@@ -231,7 +231,7 @@ namespace app {
for (Task*& i : task_work->tasks)
i->SetDest();
}
void TaskWork::Disp() {
task_work->disp = true;
for (int32_t i = 0; i < 3; i++)
@@ -369,7 +369,7 @@ namespace app {
uint32_t frame_counter = get_frame_counter();
if (frame_counter == (frame_counter / 300) * 300)
t->calc_time_max = 0;
t->calc_time = max(t->calc_time, t->calc_time_max);
t->calc_time = max_def(t->calc_time, t->calc_time_max);
}
static void Task_set_disp_time(Task* t, uint32_t disp_time) {
@@ -377,7 +377,7 @@ namespace app {
uint32_t frame_counter = get_frame_counter();
if (frame_counter == (frame_counter / 300) * 300)
t->disp_time_max = 0;
t->disp_time = max(t->disp_time, t->disp_time_max);
t->disp_time = max_def(t->disp_time, t->disp_time_max);
}
static bool Task_sub_14019B810(Task* t, int32_t a2) {
src/CRE/task_effect.cpp
+4 -5
View File
@@ -300,7 +300,7 @@ void TaskEffectFogAnim::Data::Ctrl() {
float_t v4 = field_C[0] * DEG_TO_RAD_FLOAT;
float_t v7 = (sinf(v4 - 1.5f) + 1.0f) * 0.5f + field_34.x;
v7 = min(v7, 1.0f) * field_24;
v7 = min_def(v7, 1.0f) * field_24;
float_t v8 = sinf(v4) * v7;
float_t v9 = cosf(v4);
@@ -309,7 +309,7 @@ void TaskEffectFogAnim::Data::Ctrl() {
color.y = (float_t)(1.0 - v8 * 0.345686 - ((double_t)v9 * v7) * 0.714486);
color.z = (float_t)(v8 * 1.771 + 1.0);
color.w = 1.0f;
vec3_max(*(vec3*)&color, vec3_null, *(vec3*)&color);
*(vec3*)&color = vec3::max(*(vec3*)&color, vec3_null);
for (int32_t i = 0; i < 3; i++) {
float_t v20 = (field_18[i] * 10.0f) + field_C[i];
@@ -321,8 +321,7 @@ void TaskEffectFogAnim::Data::Ctrl() {
fog& fog = rctx_ptr->fog[FOG_DEPTH];
fog.set_color(color);
vec3_add_scalar(*(vec3*)&color, 1.0f, *(vec3*)&color);
vec3_mult_scalar(*(vec3*)&color, 0.8f, *(vec3*)&color);
*(vec3*)&color = (*(vec3*)&color + 1.0f) * 0.8f;
light_set& light_set = rctx_ptr->light_set[LIGHT_SET_MAIN];
light_set.lights[LIGHT_CHARA].set_diffuse(color);
@@ -415,7 +414,7 @@ bool TaskEffectFogRing::Init() {
bool TaskEffectFogRing::Ctrl() {
data.delta_frame = data.frame_rate_control->GetDeltaFrame();
data.Ctrl();;
data.Ctrl();
return 0;
}
src/CRE/task_effect.hpp
-2
View File
@@ -63,8 +63,6 @@ public:
virtual void Field_A8(int32_t a2, int8_t* a3);
};
;
struct struc_621 {
int32_t stage_index;
std::vector<int32_t> auth_3d_ids;
src/CRE/texture.cpp
+114 -27
View File
@@ -8,6 +8,15 @@
#include "../KKdLib/txp.hpp"
#include "gl_state.hpp"
#include "static_var.hpp"
#include <map>
#include <vector>
struct texture_params {
GLenum target;
GLint wrap_s;
GLint wrap_t;
GLint wrap_r;
};
static void texture_get_format_type_by_internal_format(GLenum internal_format, GLenum* format, GLenum* type);
static uint32_t texture_get_height_align_mip_level(texture* tex, int32_t mip_level);
@@ -21,10 +30,11 @@ static int32_t texture_load(GLenum target, GLenum internal_format,
static texture* texture_load_tex(texture_id id, GLenum target,
GLenum internal_format, int32_t width, int32_t height,
int32_t max_mipmap_level, void** data_ptr, bool use_high_anisotropy);
static void texture_set_params(GLenum target, int32_t max_mipmap_level, bool use_high_anisotropy);
static void texture_set_params(GLuint texture, GLenum target, int32_t max_mipmap_level, bool use_high_anisotropy);
static GLenum texture_txp_get_internal_format(txp* t);
std::vector<texture*> texture_storage;
std::map<GLuint, texture_params> texture_params_storage;
texture_id::texture_id() : id(0), index(0) {
@@ -86,7 +96,7 @@ void texture_apply_color_tone(texture* chg_tex,
}
glBindTexture(org_tex->target, 0);
glGetError();
free(data);
free_def(data);
}
}
@@ -119,7 +129,7 @@ texture* texture_copy(texture_id id, texture* org_tex) {
org_tex->width, org_tex->height, org_tex->max_mipmap_level, vec_data.data(), true);
for (void*& i : vec_data)
free(i);
free_def(i);
return tex;
}
@@ -156,7 +166,7 @@ texture* texture_txp_load(txp* t, texture_id id) {
tex = texture_load_tex_cube_map(id, internal_format, width, height, max_mipmap_level, data_ptr);
else
tex = texture_load_tex_2d(id, internal_format, width, height, max_mipmap_level, data_ptr, true);
free(data_ptr);
free_def(data_ptr);
return tex;
}
@@ -192,6 +202,7 @@ bool texture_txp_set_load(txp_set* t, texture*** texs, texture_id* ids) {
inline void texture_storage_init() {
texture_storage = {};
texture_params_storage = {};
}
inline texture* texture_storage_create_texture(texture_id id) {
@@ -241,6 +252,7 @@ inline void texture_storage_delete_texture(texture_id id) {
break;
}
texture_params_storage.erase(tex->tex);
glDeleteTextures(1, &tex->tex);
delete tex;
i = texture_storage.erase(i);
@@ -248,12 +260,90 @@ inline void texture_storage_delete_texture(texture_id id) {
}
}
inline void texture_storage_set_texture_wrap(GLuint texture, GLint wrap_s, GLint wrap_t) {
auto elem = texture_params_storage.find(texture);
if (elem == texture_params_storage.end())
return;
texture_params& params = elem->second;
if (params.wrap_s != wrap_s) {
glTexParameteri(params.target, GL_TEXTURE_WRAP_S, wrap_s);
params.wrap_s = wrap_s;
}
if (params.wrap_t != wrap_t) {
glTexParameteri(params.target, GL_TEXTURE_WRAP_T, wrap_t);
params.wrap_t = wrap_t;
}
}
inline void texture_storage_set_texture_wrap(GLuint texture, GLint wrap_s, GLint wrap_t, GLint wrap_r) {
auto elem = texture_params_storage.find(texture);
if (elem == texture_params_storage.end())
return;
texture_params& params = elem->second;
if (params.wrap_s != wrap_s) {
glTexParameteri(params.target, GL_TEXTURE_WRAP_S, wrap_s);
params.wrap_s = wrap_s;
}
if (params.wrap_t != wrap_t) {
glTexParameteri(params.target, GL_TEXTURE_WRAP_T, wrap_t);
params.wrap_t = wrap_t;
}
if (params.wrap_r != wrap_r) {
glTexParameteri(params.target, GL_TEXTURE_WRAP_R, wrap_r);
params.wrap_r = wrap_r;
}
}
inline void texture_storage_set_texture_wrap_s(GLuint texture, GLint wrap) {
auto elem = texture_params_storage.find(texture);
if (elem == texture_params_storage.end())
return;
texture_params& params = elem->second;
if (params.wrap_s != wrap) {
glTexParameteri(params.target, GL_TEXTURE_WRAP_S, wrap);
params.wrap_s = wrap;
}
}
inline void texture_storage_set_texture_wrap_t(GLuint texture, GLint wrap) {
auto elem = texture_params_storage.find(texture);
if (elem == texture_params_storage.end())
return;
texture_params& params = elem->second;
if (params.wrap_t != wrap) {
glTexParameteri(params.target, GL_TEXTURE_WRAP_T, wrap);
params.wrap_t = wrap;
}
}
inline void texture_storage_set_texture_wrap_r(GLuint texture, GLint wrap) {
auto elem = texture_params_storage.find(texture);
if (elem == texture_params_storage.end())
return;
texture_params& params = elem->second;
if (params.wrap_r != wrap) {
glTexParameteri(params.target, GL_TEXTURE_WRAP_R, wrap);
params.wrap_r = wrap;
}
}
inline void texture_storage_free() {
for (texture*& i : texture_storage) {
if (i)
if (i) {
texture_params_storage.erase(i->tex);
glDeleteTextures(1, &i->tex);
}
delete i;
}
texture_params_storage.clear();
texture_storage.clear();
texture_storage.shrink_to_fit();
}
@@ -372,13 +462,13 @@ static void texture_get_format_type_by_internal_format(GLenum internal_format, G
inline static uint32_t texture_get_height_align_mip_level(texture* tex, int32_t mip_level) {
uint32_t height = tex->height >> mip_level;
if (tex->flags & TEXTURE_BLOCK_COMPRESSION)
return max(height, 4);
return max(height, 1);
return max_def(height, 4);
return max_def(height, 1);
}
inline static uint32_t texture_get_height_mip_level(texture* tex, int32_t mip_level) {
uint32_t height = tex->height >> mip_level;
return max(height, 1);
return max_def(height, 1);
}
static int32_t texture_get_size(GLenum internal_format, int32_t width, int32_t height) {
@@ -431,19 +521,19 @@ static int32_t texture_get_size(GLenum internal_format, int32_t width, int32_t h
inline static int32_t texture_get_size_mip_level(texture* tex, int32_t mip_level) {
int32_t width = tex->width >> mip_level;
int32_t height = tex->height >> mip_level;
return texture_get_size(tex->internal_format, max(width, 1), max(height, 1));
return texture_get_size(tex->internal_format, max_def(width, 1), max_def(height, 1));
}
inline static uint32_t texture_get_width_align_mip_level(texture* tex, int32_t mip_level) {
uint32_t width = tex->width >> mip_level;
if (tex->flags & TEXTURE_BLOCK_COMPRESSION)
return max(width, 4);
return max(width, 1);
return max_def(width, 4);
return max_def(width, 1);
}
inline static uint32_t texture_get_width_mip_level(texture* tex, int32_t mip_level) {
uint32_t width = tex->width >> mip_level;
return max(width, 1);
return max_def(width, 1);
}
static int32_t texture_load(GLenum target, GLenum internal_format,
@@ -478,6 +568,7 @@ static texture* texture_load_tex(texture_id id, GLenum target,
return tex;
glGenTextures(1, &tex->tex);
texture_params_storage.insert({ tex->tex, { target } });
switch (target) {
case GL_TEXTURE_2D:
gl_state_bind_texture_2d(tex->tex);
@@ -486,7 +577,7 @@ static texture* texture_load_tex(texture_id id, GLenum target,
gl_state_bind_texture_cube_map(tex->tex);
break;
}
texture_set_params(target, max_mipmap_level, use_high_anisotropy);
texture_set_params(tex->tex, target, max_mipmap_level, use_high_anisotropy);
GLint swizzle[4];
switch (internal_format) {
@@ -534,8 +625,8 @@ static texture* texture_load_tex(texture_id id, GLenum target,
if (target == GL_TEXTURE_CUBE_MAP)
for (int32_t i = 0; i < 6; i++)
for (int32_t j = 0; j <= max_mipmap_level; j++) {
int32_t mip_width = max(width >> j, 1);
int32_t mip_height = max(height >> j, 1);
int32_t mip_width = max_def(width >> j, 1);
int32_t mip_height = max_def(height >> j, 1);
void* data;
if (data_ptr)
data = data_ptr[i * (max_mipmap_level + 1) + j];
@@ -555,8 +646,8 @@ static texture* texture_load_tex(texture_id id, GLenum target,
}
else
for (int32_t i = 0; i <= max_mipmap_level; i++) {
int32_t mip_width = max(width >> i, 1);
int32_t mip_height = max(height >> i, 1);
int32_t mip_width = max_def(width >> i, 1);
int32_t mip_height = max_def(height >> i, 1);
void* data;
if (data_ptr)
data = data_ptr[i];
@@ -611,24 +702,20 @@ fail:
return 0;
}
static void texture_set_params(GLenum target, int32_t max_mipmap_level, bool use_high_anisotropy) {
glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
static void texture_set_params(GLuint texture, GLenum target, int32_t max_mipmap_level, bool use_high_anisotropy) {
texture_storage_set_texture_wrap(target, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
glTexParameterfv(target, GL_TEXTURE_BORDER_COLOR, (float_t*)&vec4_null);
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
GLenum min_filter = GL_LINEAR;
if (max_mipmap_level > 0)
min_filter = GL_LINEAR_MIPMAP_LINEAR;
glTexParameteri(target, GL_TEXTURE_MIN_FILTER, min_filter);
glTexParameteri(target, GL_TEXTURE_MIN_FILTER,
max_mipmap_level > 0 ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, max_mipmap_level);
float_t max_anisotropy;
if (use_high_anisotropy)
max_anisotropy = 16.0;
max_anisotropy = 16.0f;
else
max_anisotropy = 1.0;
max_anisotropy = 1.0f;
glTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropy);
}
src/CRE/texture.hpp
+5 -1
View File
@@ -5,7 +5,6 @@
#pragma once
#include <vector>
#include "../KKdLib/default.hpp"
#include "../KKdLib/image.hpp"
#include "../KKdLib/txp.hpp"
@@ -83,4 +82,9 @@ extern texture* texture_storage_get_texture(texture_id id);
extern size_t texture_storage_get_texture_count();
extern texture* texture_storage_get_texture_by_index(size_t index);
extern void texture_storage_delete_texture(texture_id id);
extern void texture_storage_set_texture_wrap(GLuint texture, GLint wrap_s, GLint wrap_t);
extern void texture_storage_set_texture_wrap(GLuint texture, GLint wrap_s, GLint wrap_t, GLint wrap_r);
extern void texture_storage_set_texture_wrap_s(GLuint texture, GLint wrap);
extern void texture_storage_set_texture_wrap_t(GLuint texture, GLint wrap);
extern void texture_storage_set_texture_wrap_r(GLuint texture, GLint wrap);
extern void texture_storage_free();
src/CRE/timer.cpp
+61 -64
View File
@@ -5,109 +5,106 @@
#include "timer.hpp"
timer::timer(double_t freq) : history() {
timer::timer(double_t freq) : history(), curr_time(), prev_time(), inv_freq() {
for (double_t& i : history)
i = freq;
history_counter = 0;
this->freq = freq;
this->freq_hist = freq;
lock_init(&freq_lock);
lock_init(&freq_hist_lock);
timer_handle = timer_handle_init();
LARGE_INTEGER frequency;
if (QueryPerformanceFrequency(&frequency))
inv_freq = 1000.0 / (double_t)frequency.LowPart;
else
inv_freq = 0.0;
if (!QueryPerformanceCounter(&curr_time))
curr_time.QuadPart = 0;
if (!QueryPerformanceCounter(&prev_time))
prev_time.QuadPart = 0;
}
timer::~timer() {
lock_free(&freq_lock);
lock_free(&freq_hist_lock);
timer_handle_dispose(timer_handle);
}
void timer::start_of_cycle() {
double_t time = prev_time.calc_time();
prev_time.get_timestamp();
double_t freq = 0;
LARGE_INTEGER timestamp;
if (!QueryPerformanceCounter(&timestamp))
timestamp.QuadPart = 0;
double_t time = (timestamp.QuadPart - curr_time.QuadPart) * inv_freq;
if (!QueryPerformanceCounter(&curr_time))
curr_time.QuadPart = 0;
history[history_counter] = time;
double_t freq = 0.0;
for (uint8_t i = 0; i < history_counter; i++)
freq += history[i];
freq += history[history_counter] = 1000.0 / time;
freq += time;
for (uint8_t i = history_counter + 1; i < HISTORY_COUNT; i++)
freq += history[i];
history_counter++;
if (history_counter >= HISTORY_COUNT)
history_counter = 0;
lock_lock(&freq_hist_lock);
freq_hist = freq / HISTORY_COUNT;
lock_unlock(&freq_hist_lock);
std::unique_lock<std::mutex> u_lock(freq_mtx);
freq_hist = 1000.0 / (freq / HISTORY_COUNT);
}
void timer::end_of_cycle() {
double_t msec = 1000.0 / get_freq() - prev_time.calc_time();
timer_handle_sleep(timer_handle, msec);
LONGLONG& curr_timestamp = curr_time.QuadPart;
LONGLONG& prev_timestamp = prev_time.QuadPart;
double_t msec = 1000.0 / get_freq() - (curr_timestamp - prev_timestamp) * inv_freq;
if (floor(msec) > 0)
wait_timer.sleep_float(msec);
if (msec < -get_freq() / 4.0)
prev_timestamp = curr_timestamp - (LONGLONG)(get_freq() / 4.0 / inv_freq);
else
prev_timestamp = curr_timestamp + (LONGLONG)(msec / inv_freq);
}
double_t timer::get_freq() {
double_t freq = 0.0;
lock_lock(&freq_lock);
freq = this->freq;
lock_unlock(&freq_lock);
std::unique_lock<std::mutex> u_lock(freq_mtx);
return freq;
}
void timer::set_freq(double_t freq) {
lock_lock(&freq_lock);
std::unique_lock<std::mutex> u_lock(freq_mtx);
this->freq = freq;
lock_unlock(&freq_lock);
}
double_t timer::get_freq_hist() {
double_t freq = 0.0;
lock_lock(&freq_hist_lock);
freq = freq_hist;
lock_unlock(&freq_hist_lock);
return freq;
std::unique_lock<std::mutex> u_lock(freq_hist_mtx);
return freq_hist;
}
double_t timer::get_freq_ratio() {
double_t freq = 0.0;
lock_lock(&freq_lock);
freq = this->freq;
lock_unlock(&freq_lock);
lock_lock(&freq_hist_lock);
freq /= freq_hist;
lock_unlock(&freq_hist_lock);
return freq;
double_t freq_ratio = 0.0;
{
std::unique_lock<std::mutex> u_lock(freq_mtx);
freq_ratio = freq;
}
{
std::unique_lock<std::mutex> u_lock(freq_hist_mtx);
freq_ratio /= freq_hist;
}
return freq_ratio;
}
void timer::reset() {
curr_time.get_timestamp();
prev_time.get_timestamp();
if (!QueryPerformanceCounter(&curr_time))
curr_time.QuadPart = 0;
if (!QueryPerformanceCounter(&prev_time))
prev_time.QuadPart = 0;
}
void timer::sleep(double_t msec) {
timer_handle_sleep(timer_handle, msec);
}
inline HANDLE timer_handle_init() {
return CreateWaitableTimerW(0, 0, 0);
}
inline void timer_handle_sleep(HANDLE timer, double_t msec) {
if (msec <= 0.0)
return;
if (timer) {
LARGE_INTEGER t;
t.QuadPart = (LONGLONG)round(msec * -10000.0);
SetWaitableTimer(timer, &t, 0, 0, 0, 0);
WaitForSingleObject(timer, INFINITE);
}
else {
DWORD msec_dw = (DWORD)round(msec);
if (msec_dw)
Sleep(msec_dw);
}
}
inline void timer_handle_dispose(HANDLE timer) {
if (timer)
CloseHandle(timer);
wait_timer.sleep_float(msec);
}
src/CRE/timer.hpp
+8 -13
View File
@@ -6,21 +6,22 @@
#pragma once
#include "../KKdLib/default.hpp"
#include "lock.hpp"
#include "time.hpp"
#include "waitable_timer.hpp"
#include <mutex>
#define HISTORY_COUNT 0x08
struct timer {
double_t history[HISTORY_COUNT];
uint8_t history_counter;
time_struct curr_time;
time_struct prev_time;
LARGE_INTEGER curr_time;
LARGE_INTEGER prev_time;
double_t inv_freq;
double_t freq;
double_t freq_hist;
lock freq_lock;
lock freq_hist_lock;
HANDLE timer_handle;
std::mutex freq_mtx;
std::mutex freq_hist_mtx;
waitable_timer wait_timer;
timer(double_t freq);
virtual ~timer();
@@ -34,9 +35,3 @@ struct timer {
void reset();
void sleep(double_t msec);
};
extern LARGE_INTEGER performance_frequency;
extern HANDLE timer_handle_init();
extern void timer_handle_sleep(HANDLE timer, double_t msec);
extern void timer_handle_dispose(HANDLE timer);
src/CRE/waitable_timer.hpp
+57
View File
@@ -0,0 +1,57 @@
/*
by korenkonder
GitHub/GitLab: korenkonder
*/
#pragma once
#include "../KKdLib/default.hpp"
struct waitable_timer {
HANDLE handle;
inline waitable_timer() {
handle = CreateWaitableTimerW(0, 0, 0);
}
inline ~waitable_timer() {
if (handle) {
CloseHandle(handle);
handle = 0;
}
}
inline void sleep(int64_t msec) {
if (msec <= 0.0)
return;
if (handle) {
LARGE_INTEGER t;
t.QuadPart = (LONGLONG)(msec * -10000);
SetWaitableTimer(handle, &t, 0, 0, 0, 0);
WaitForSingleObject(handle, INFINITE);
}
else {
DWORD msec_dw = (DWORD)msec;
if (msec_dw)
Sleep(msec_dw);
}
}
inline void sleep_float(double_t msec) {
if (msec <= 0.0)
return;
if (handle) {
LARGE_INTEGER t;
t.QuadPart = (LONGLONG)round(msec * -10000.0);
SetWaitableTimer(handle, &t, 0, 0, 0, 0);
WaitForSingleObject(handle, INFINITE);
}
else {
DWORD msec_dw = (DWORD)round(msec);
if (msec_dw)
Sleep(msec_dw);
}
}
};
src/DivaGL/DivaGL.vcxproj
+4 -4
View File
@@ -248,7 +248,7 @@ del "$(SolutionDir)bin\$(TargetName).lib"</Command>
<ClCompile>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<Optimization>Full</Optimization>
<PreprocessorDefinitions>WIN32;DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>$(SolutionDir)extern\src</AdditionalIncludeDirectories>
<ConformanceMode>true</ConformanceMode>
@@ -286,7 +286,7 @@ del "$(SolutionDir)bin\$(TargetName).lib"</Command>
<ClCompile>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<Optimization>Full</Optimization>
<PreprocessorDefinitions>WIN32;DEBUG;DIVAGL_DEV;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>$(SolutionDir)extern\src</AdditionalIncludeDirectories>
<ConformanceMode>true</ConformanceMode>
@@ -417,7 +417,7 @@ del "$(SolutionDir)bin\$(TargetName).lib"</Command>
<EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
<OmitFramePointers>false</OmitFramePointers>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<IntrinsicFunctions>true</IntrinsicFunctions>
<CallingConvention>FastCall</CallingConvention>
<CompileAs>CompileAsCpp</CompileAs>
@@ -459,7 +459,7 @@ del "$(SolutionDir)bin\$(TargetName).lib"</Command>
<EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
<OmitFramePointers>false</OmitFramePointers>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<IntrinsicFunctions>true</IntrinsicFunctions>
<CallingConvention>FastCall</CallingConvention>
<CompileAs>CompileAsCpp</CompileAs>

Some files were not shown because too many files have changed in this diff Show More